helm_sdk/

types_gen.rs

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct AccountEntitlements {
    #[serde(rename = "principal_id", skip_serializing_if = "Option::is_none")]
    pub principal_id: Option<String>,
    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "workspace_id", skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(rename = "plan", default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<Option<AccountEntitlementsPlan>>,
    #[serde(rename = "plan_id", skip_serializing_if = "Option::is_none")]
    pub plan_id: Option<String>,
    #[serde(rename = "capabilities", skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<Box<EntitlementCapabilities>>,
    #[serde(rename = "limits", skip_serializing_if = "Option::is_none")]
    pub limits: Option<Box<EntitlementLimits>>,
    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    #[serde(rename = "updated_at", skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

impl AccountEntitlements {
    pub fn new() -> AccountEntitlements {
        AccountEntitlements {
            principal_id: None,
            tenant_id: None,
            workspace_id: None,
            plan: None,
            plan_id: None,
            capabilities: None,
            limits: None,
            source: None,
            updated_at: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum AccountEntitlementsPlan {
    #[serde(rename = "free")]
    Free,
    #[serde(rename = "developer")]
    Developer,
    #[serde(rename = "team")]
    Team,
    #[serde(rename = "scale")]
    Scale,
    #[serde(rename = "enterprise")]
    Enterprise,
}

impl Default for AccountEntitlementsPlan {
    fn default() -> AccountEntitlementsPlan {
        Self::Free
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct AccountSession {
    #[serde(rename = "session_id", skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    #[serde(rename = "principal_id", skip_serializing_if = "Option::is_none")]
    pub principal_id: Option<String>,
    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "workspace_id", skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(rename = "plan", default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<Option<AccountSessionPlan>>,
    #[serde(rename = "plan_id", skip_serializing_if = "Option::is_none")]
    pub plan_id: Option<String>,
    #[serde(rename = "edition", skip_serializing_if = "Option::is_none")]
    pub edition: Option<String>,
    #[serde(rename = "deployment_mode", skip_serializing_if = "Option::is_none")]
    pub deployment_mode: Option<String>,
    #[serde(rename = "account_lifecycle", skip_serializing_if = "Option::is_none")]
    pub account_lifecycle: Option<String>,
    #[serde(rename = "offer_code", skip_serializing_if = "Option::is_none")]
    pub offer_code: Option<String>,
    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    #[serde(rename = "expires_at", skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
}

impl AccountSession {
    pub fn new() -> AccountSession {
        AccountSession {
            session_id: None,
            principal_id: None,
            tenant_id: None,
            workspace_id: None,
            plan: None,
            plan_id: None,
            edition: None,
            deployment_mode: None,
            account_lifecycle: None,
            offer_code: None,
            source: None,
            expires_at: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum AccountSessionPlan {
    #[serde(rename = "free")]
    Free,
    #[serde(rename = "developer")]
    Developer,
    #[serde(rename = "team")]
    Team,
    #[serde(rename = "scale")]
    Scale,
    #[serde(rename = "enterprise")]
    Enterprise,
}

impl Default for AccountSessionPlan {
    fn default() -> AccountSessionPlan {
        Self::Free
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct AdapterMatch {
    #[serde(rename = "adapter_id", skip_serializing_if = "Option::is_none")]
    pub adapter_id: Option<String>,
    #[serde(rename = "confidence", skip_serializing_if = "Option::is_none")]
    pub confidence: Option<f64>,
    #[serde(rename = "evidence", skip_serializing_if = "Option::is_none")]
    pub evidence: Option<Vec<String>>,
}

impl AdapterMatch {
    pub fn new() -> AdapterMatch {
        AdapterMatch {
            adapter_id: None,
            confidence: None,
            evidence: 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl ApproveLaunchpadMcpToolsRequest {
    pub fn new(server_id: String, tools: Vec<String>, reason: String) -> ApproveLaunchpadMcpToolsRequest {
        ApproveLaunchpadMcpToolsRequest {
            server_id,
            tools,
            ttl: None,
            reason,
            approver: 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BindLaunchpadSecretGrantRequest {
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "provider")]
    pub provider: String,
    #[serde(rename = "value_env")]
    pub value_env: String,
}

impl BindLaunchpadSecretGrantRequest {
    pub fn new(name: String, provider: String, value_env: String) -> BindLaunchpadSecretGrantRequest {
        BindLaunchpadSecretGrantRequest {
            name,
            provider,
            value_env,
        }
    }
}

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


/// BoundaryStatus : Runtime health summary for the OSS-local execution boundary. A ready status means both receipt storage and receipt signing are available; otherwise status is degraded and the unavailable mechanism is named by receipt_store or receipt_signer.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BoundaryStatus {
    #[serde(rename = "status")]
    pub status: BoundaryStatusStatus,
    #[serde(rename = "mode")]
    pub mode: BoundaryStatusMode,
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "receipt_signer")]
    pub receipt_signer: BoundaryStatusReceiptSigner,
    #[serde(rename = "receipt_store")]
    pub receipt_store: BoundaryStatusReceiptStore,
    #[serde(rename = "pdp")]
    pub pdp: BoundaryStatusPdp,
    #[serde(rename = "mcp_firewall")]
    pub mcp_firewall: BoundaryStatusMcpFirewall,
    #[serde(rename = "sandbox")]
    pub sandbox: BoundaryStatusSandbox,
    #[serde(rename = "authz")]
    pub authz: BoundaryStatusAuthz,
    #[serde(rename = "evidence_verifier")]
    pub evidence_verifier: BoundaryStatusEvidenceVerifier,
    #[serde(rename = "checkpoint_log")]
    pub checkpoint_log: BoundaryStatusCheckpointLog,
    #[serde(rename = "last_checkpoint_hash", skip_serializing_if = "Option::is_none")]
    pub last_checkpoint_hash: Option<String>,
    #[serde(rename = "open_approval_count")]
    pub open_approval_count: i32,
    #[serde(rename = "quarantined_mcp_count")]
    pub quarantined_mcp_count: i32,
    #[serde(rename = "updated_at")]
    pub updated_at: String,
    #[serde(rename = "components", skip_serializing_if = "Option::is_none")]
    pub components: Option<std::collections::HashMap<String, String>>,
}

impl BoundaryStatus {
    /// Runtime health summary for the OSS-local execution boundary. A ready status means both receipt storage and receipt signing are available; otherwise status is degraded and the unavailable mechanism is named by receipt_store or receipt_signer.
    pub fn new(status: BoundaryStatusStatus, mode: BoundaryStatusMode, receipt_signer: BoundaryStatusReceiptSigner, receipt_store: BoundaryStatusReceiptStore, pdp: BoundaryStatusPdp, mcp_firewall: BoundaryStatusMcpFirewall, sandbox: BoundaryStatusSandbox, authz: BoundaryStatusAuthz, evidence_verifier: BoundaryStatusEvidenceVerifier, checkpoint_log: BoundaryStatusCheckpointLog, open_approval_count: i32, quarantined_mcp_count: i32, updated_at: String) -> BoundaryStatus {
        BoundaryStatus {
            status,
            mode,
            version: None,
            receipt_signer,
            receipt_store,
            pdp,
            mcp_firewall,
            sandbox,
            authz,
            evidence_verifier,
            checkpoint_log,
            last_checkpoint_hash: None,
            open_approval_count,
            quarantined_mcp_count,
            updated_at,
            components: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusStatus {
    #[serde(rename = "degraded")]
    Degraded,
    #[serde(rename = "ready")]
    Ready,
}

impl Default for BoundaryStatusStatus {
    fn default() -> BoundaryStatusStatus {
        Self::Degraded
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusMode {
    #[serde(rename = "oss-local")]
    OssLocal,
}

impl Default for BoundaryStatusMode {
    fn default() -> BoundaryStatusMode {
        Self::OssLocal
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusReceiptSigner {
    #[serde(rename = "unavailable")]
    Unavailable,
    #[serde(rename = "ready")]
    Ready,
}

impl Default for BoundaryStatusReceiptSigner {
    fn default() -> BoundaryStatusReceiptSigner {
        Self::Unavailable
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusReceiptStore {
    #[serde(rename = "unavailable")]
    Unavailable,
    #[serde(rename = "ready")]
    Ready,
}

impl Default for BoundaryStatusReceiptStore {
    fn default() -> BoundaryStatusReceiptStore {
        Self::Unavailable
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusPdp {
    #[serde(rename = "fail-closed")]
    FailClosed,
}

impl Default for BoundaryStatusPdp {
    fn default() -> BoundaryStatusPdp {
        Self::FailClosed
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusMcpFirewall {
    #[serde(rename = "enabled")]
    Enabled,
}

impl Default for BoundaryStatusMcpFirewall {
    fn default() -> BoundaryStatusMcpFirewall {
        Self::Enabled
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusSandbox {
    #[serde(rename = "deny-default")]
    DenyDefault,
}

impl Default for BoundaryStatusSandbox {
    fn default() -> BoundaryStatusSandbox {
        Self::DenyDefault
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusAuthz {
    #[serde(rename = "rebac-snapshot")]
    RebacSnapshot,
}

impl Default for BoundaryStatusAuthz {
    fn default() -> BoundaryStatusAuthz {
        Self::RebacSnapshot
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusEvidenceVerifier {
    #[serde(rename = "offline")]
    Offline,
}

impl Default for BoundaryStatusEvidenceVerifier {
    fn default() -> BoundaryStatusEvidenceVerifier {
        Self::Offline
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum BoundaryStatusCheckpointLog {
    #[serde(rename = "tamper-evident")]
    TamperEvident,
}

impl Default for BoundaryStatusCheckpointLog {
    fn default() -> BoundaryStatusCheckpointLog {
        Self::TamperEvident
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BuildStrategy {
    #[serde(rename = "strategy", skip_serializing_if = "Option::is_none")]
    pub strategy: Option<String>,
    #[serde(rename = "confidence", skip_serializing_if = "Option::is_none")]
    pub confidence: Option<f64>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "commands", skip_serializing_if = "Option::is_none")]
    pub commands: Option<Vec<Vec<String>>>,
    #[serde(rename = "manifest_sources", skip_serializing_if = "Option::is_none")]
    pub manifest_sources: Option<Vec<String>>,
}

impl BuildStrategy {
    pub fn new() -> BuildStrategy {
        BuildStrategy {
            strategy: None,
            confidence: None,
            reason: None,
            commands: None,
            manifest_sources: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct CapabilityGraph {
    #[serde(rename = "capabilities", skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<Vec<String>>,
    #[serde(rename = "modules", skip_serializing_if = "Option::is_none")]
    pub modules: Option<Vec<DetectedModule>>,
    #[serde(rename = "frameworks", skip_serializing_if = "Option::is_none")]
    pub frameworks: Option<Vec<DetectedFramework>>,
    #[serde(rename = "secrets", skip_serializing_if = "Option::is_none")]
    pub secrets: Option<Vec<SecretContract>>,
    #[serde(rename = "oauth", skip_serializing_if = "Option::is_none")]
    pub oauth: Option<Vec<OAuthRequirement>>,
    #[serde(rename = "ports", skip_serializing_if = "Option::is_none")]
    pub ports: Option<Vec<i32>>,
    #[serde(rename = "build_signals", skip_serializing_if = "Option::is_none")]
    pub build_signals: Option<Vec<String>>,
    #[serde(rename = "runtime_signals", skip_serializing_if = "Option::is_none")]
    pub runtime_signals: Option<Vec<String>>,
    #[serde(rename = "policy_signals", skip_serializing_if = "Option::is_none")]
    pub policy_signals: Option<Vec<String>>,
    #[serde(rename = "security_signals", skip_serializing_if = "Option::is_none")]
    pub security_signals: Option<Vec<String>>,
    #[serde(rename = "adapter_matches", skip_serializing_if = "Option::is_none")]
    pub adapter_matches: Option<Vec<AdapterMatch>>,
    #[serde(rename = "confidence", skip_serializing_if = "Option::is_none")]
    pub confidence: Option<f64>,
    #[serde(rename = "confidence_reason", skip_serializing_if = "Option::is_none")]
    pub confidence_reason: Option<String>,
}

impl CapabilityGraph {
    pub fn new() -> CapabilityGraph {
        CapabilityGraph {
            capabilities: None,
            modules: None,
            frameworks: None,
            secrets: None,
            oauth: None,
            ports: None,
            build_signals: None,
            runtime_signals: None,
            policy_signals: None,
            security_signals: None,
            adapter_matches: None,
            confidence: None,
            confidence_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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl ConsoleCapabilities {
    pub fn new(entitlements: Vec<String>, version: String) -> ConsoleCapabilities {
        ConsoleCapabilities {
            entitlements,
            version,
            source: None,
            tier_gate: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleDiagnostics {
    #[serde(rename = "generated_at")]
    pub generated_at: String,
    #[serde(rename = "runtime")]
    pub runtime: std::collections::HashMap<String, serde_json::Value>,
    #[serde(rename = "access")]
    pub access: std::collections::HashMap<String, serde_json::Value>,
    #[serde(rename = "stores")]
    pub stores: Vec<ConsoleStoreDiagnostic>,
    #[serde(rename = "routes")]
    pub routes: Vec<ConsoleRouteDiagnostic>,
}

impl ConsoleDiagnostics {
    pub fn new(generated_at: String, runtime: std::collections::HashMap<String, serde_json::Value>, access: std::collections::HashMap<String, serde_json::Value>, stores: Vec<ConsoleStoreDiagnostic>, routes: Vec<ConsoleRouteDiagnostic>) -> ConsoleDiagnostics {
        ConsoleDiagnostics {
            generated_at,
            runtime,
            access,
            stores,
            routes,
        }
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleRouteDiagnostic {
    #[serde(rename = "method")]
    pub method: String,
    #[serde(rename = "path")]
    pub path: String,
    #[serde(rename = "mux_pattern", skip_serializing_if = "Option::is_none")]
    pub mux_pattern: Option<String>,
    #[serde(rename = "auth")]
    pub auth: String,
    #[serde(rename = "rate_limit", skip_serializing_if = "Option::is_none")]
    pub rate_limit: Option<String>,
    #[serde(rename = "contract_status")]
    pub contract_status: String,
    #[serde(rename = "operation_id")]
    pub operation_id: String,
    #[serde(rename = "owner")]
    pub owner: String,
    #[serde(rename = "group")]
    pub group: String,
    #[serde(rename = "ui_coverage", skip_serializing_if = "Option::is_none")]
    pub ui_coverage: Option<String>,
    #[serde(rename = "unsupported_reason", skip_serializing_if = "Option::is_none")]
    pub unsupported_reason: Option<String>,
}

impl ConsoleRouteDiagnostic {
    pub fn new(method: String, path: String, auth: String, contract_status: String, operation_id: String, owner: String, group: String) -> ConsoleRouteDiagnostic {
        ConsoleRouteDiagnostic {
            method,
            path,
            mux_pattern: None,
            auth,
            rate_limit: None,
            contract_status,
            operation_id,
            owner,
            group,
            ui_coverage: None,
            unsupported_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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleStoreDiagnostic {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "label")]
    pub label: String,
    #[serde(rename = "status")]
    pub status: String,
    #[serde(rename = "backend")]
    pub backend: String,
    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    #[serde(rename = "path", skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(rename = "detail", skip_serializing_if = "Option::is_none")]
    pub detail: Option<String>,
}

impl ConsoleStoreDiagnostic {
    pub fn new(id: String, label: String, status: String, backend: String) -> ConsoleStoreDiagnostic {
        ConsoleStoreDiagnostic {
            id,
            label,
            status,
            backend,
            source: None,
            path: None,
            detail: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleSurfaceRef {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "label", skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    #[serde(rename = "group", skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    #[serde(rename = "source")]
    pub source: String,
    #[serde(rename = "auth", skip_serializing_if = "Option::is_none")]
    pub auth: Option<String>,
    #[serde(rename = "contract_status", skip_serializing_if = "Option::is_none")]
    pub contract_status: Option<String>,
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "unsupported_reason", skip_serializing_if = "Option::is_none")]
    pub unsupported_reason: Option<String>,
    #[serde(rename = "routes", skip_serializing_if = "Option::is_none")]
    pub routes: Option<Vec<ConsoleRouteDiagnostic>>,
}

impl ConsoleSurfaceRef {
    pub fn new(id: String, source: String) -> ConsoleSurfaceRef {
        ConsoleSurfaceRef {
            id,
            label: None,
            group: None,
            source,
            auth: None,
            contract_status: None,
            status: None,
            unsupported_reason: None,
            routes: 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl CreateLaunchpadImport202Response {
    pub fn new(import: LaunchpadImportRecord) -> CreateLaunchpadImport202Response {
        CreateLaunchpadImport202Response {
            import: Box::new(import),
            cli_equivalent: 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct DetectedFramework {
    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "confidence", skip_serializing_if = "Option::is_none")]
    pub confidence: Option<f64>,
    #[serde(rename = "evidence", skip_serializing_if = "Option::is_none")]
    pub evidence: Option<Vec<String>>,
}

impl DetectedFramework {
    pub fn new() -> DetectedFramework {
        DetectedFramework {
            id: None,
            name: None,
            confidence: None,
            evidence: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct DetectedModule {
    #[serde(rename = "path", skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(rename = "kind", skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(rename = "manifests", skip_serializing_if = "Option::is_none")]
    pub manifests: Option<Vec<String>>,
    #[serde(rename = "entrypoints", skip_serializing_if = "Option::is_none")]
    pub entrypoints: Option<Vec<String>>,
    #[serde(rename = "build_strategy", skip_serializing_if = "Option::is_none")]
    pub build_strategy: Option<String>,
}

impl DetectedModule {
    pub fn new() -> DetectedModule {
        DetectedModule {
            path: None,
            kind: None,
            manifests: None,
            entrypoints: None,
            build_strategy: 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EntitlementCapabilities {
    #[serde(rename = "demo_launch", skip_serializing_if = "Option::is_none")]
    pub demo_launch: Option<bool>,
    #[serde(rename = "local_launch", skip_serializing_if = "Option::is_none")]
    pub local_launch: Option<bool>,
    #[serde(rename = "cloud_launch", skip_serializing_if = "Option::is_none")]
    pub cloud_launch: Option<bool>,
    #[serde(rename = "custom_policy", skip_serializing_if = "Option::is_none")]
    pub custom_policy: Option<bool>,
    #[serde(rename = "bring_own_secrets", skip_serializing_if = "Option::is_none")]
    pub bring_own_secrets: Option<bool>,
    #[serde(rename = "evidence_export", skip_serializing_if = "Option::is_none")]
    pub evidence_export: Option<bool>,
    #[serde(rename = "offline_verify", skip_serializing_if = "Option::is_none")]
    pub offline_verify: Option<bool>,
    #[serde(rename = "team_admin", skip_serializing_if = "Option::is_none")]
    pub team_admin: Option<bool>,
    #[serde(rename = "sso", skip_serializing_if = "Option::is_none")]
    pub sso: Option<bool>,
    #[serde(rename = "legal_hold", skip_serializing_if = "Option::is_none")]
    pub legal_hold: Option<bool>,
    #[serde(rename = "certified_connectors", skip_serializing_if = "Option::is_none")]
    pub certified_connectors: Option<bool>,
    #[serde(rename = "enterprise_retention", skip_serializing_if = "Option::is_none")]
    pub enterprise_retention: Option<bool>,
}

impl EntitlementCapabilities {
    pub fn new() -> EntitlementCapabilities {
        EntitlementCapabilities {
            demo_launch: None,
            local_launch: None,
            cloud_launch: None,
            custom_policy: None,
            bring_own_secrets: None,
            evidence_export: None,
            offline_verify: None,
            team_admin: None,
            sso: None,
            legal_hold: None,
            certified_connectors: None,
            enterprise_retention: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EntitlementDecision {
    #[serde(rename = "allowed", skip_serializing_if = "Option::is_none")]
    pub allowed: Option<bool>,
    #[serde(rename = "user_state", skip_serializing_if = "Option::is_none")]
    pub user_state: Option<EntitlementDecisionUserState>,
    #[serde(rename = "required_capability", skip_serializing_if = "Option::is_none")]
    pub required_capability: Option<String>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "upgrade_reason", skip_serializing_if = "Option::is_none")]
    pub upgrade_reason: Option<String>,
    #[serde(rename = "limit", skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(rename = "used", skip_serializing_if = "Option::is_none")]
    pub used: Option<i64>,
    #[serde(rename = "remaining", skip_serializing_if = "Option::is_none")]
    pub remaining: Option<i64>,
    #[serde(rename = "decision_ref", skip_serializing_if = "Option::is_none")]
    pub decision_ref: Option<String>,
    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    #[serde(rename = "expires_at", skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
}

impl EntitlementDecision {
    pub fn new() -> EntitlementDecision {
        EntitlementDecision {
            allowed: None,
            user_state: None,
            required_capability: None,
            reason_code: None,
            reason: None,
            upgrade_reason: None,
            limit: None,
            used: None,
            remaining: None,
            decision_ref: None,
            source: None,
            expires_at: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum EntitlementDecisionUserState {
    #[serde(rename = "available")]
    Available,
    #[serde(rename = "needs_setup")]
    NeedsSetup,
    #[serde(rename = "upgrade_required")]
    UpgradeRequired,
    #[serde(rename = "enterprise_controlled")]
    EnterpriseControlled,
    #[serde(rename = "blocked")]
    Blocked,
    #[serde(rename = "unsupported")]
    Unsupported,
}

impl Default for EntitlementDecisionUserState {
    fn default() -> EntitlementDecisionUserState {
        Self::Available
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EntitlementDecisionRequest {
    #[serde(rename = "principal_id", skip_serializing_if = "Option::is_none")]
    pub principal_id: Option<String>,
    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "workspace_id", skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(rename = "action")]
    pub action: String,
    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
    pub app_id: Option<String>,
    #[serde(rename = "substrate_id", skip_serializing_if = "Option::is_none")]
    pub substrate_id: Option<String>,
    #[serde(rename = "target", skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
    #[serde(rename = "current_usage", skip_serializing_if = "Option::is_none")]
    pub current_usage: Option<Box<EntitlementDecisionRequestCurrentUsage>>,
    #[serde(rename = "run_id", skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
}

impl EntitlementDecisionRequest {
    pub fn new(action: String) -> EntitlementDecisionRequest {
        EntitlementDecisionRequest {
            principal_id: None,
            tenant_id: None,
            workspace_id: None,
            action,
            app_id: None,
            substrate_id: None,
            target: None,
            current_usage: None,
            run_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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EntitlementDecisionRequestCurrentUsage {
    #[serde(rename = "monthly_launches", default, skip_serializing_if = "Option::is_none")]
    pub monthly_launches: Option<Option<serde_json::Value>>,
    #[serde(rename = "concurrent_runs", default, skip_serializing_if = "Option::is_none")]
    pub concurrent_runs: Option<Option<serde_json::Value>>,
    #[serde(rename = "cloud_targets", default, skip_serializing_if = "Option::is_none")]
    pub cloud_targets: Option<Option<serde_json::Value>>,
}

impl EntitlementDecisionRequestCurrentUsage {
    pub fn new() -> EntitlementDecisionRequestCurrentUsage {
        EntitlementDecisionRequestCurrentUsage {
            monthly_launches: None,
            concurrent_runs: None,
            cloud_targets: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EntitlementLimits {
    #[serde(rename = "monthly_launches", default, skip_serializing_if = "Option::is_none")]
    pub monthly_launches: Option<Option<serde_json::Value>>,
    #[serde(rename = "concurrent_runs", default, skip_serializing_if = "Option::is_none")]
    pub concurrent_runs: Option<Option<serde_json::Value>>,
    #[serde(rename = "retention_days", default, skip_serializing_if = "Option::is_none")]
    pub retention_days: Option<Option<serde_json::Value>>,
    #[serde(rename = "max_cloud_targets", default, skip_serializing_if = "Option::is_none")]
    pub max_cloud_targets: Option<Option<serde_json::Value>>,
    #[serde(rename = "evidence_export_mb", default, skip_serializing_if = "Option::is_none")]
    pub evidence_export_mb: Option<Option<serde_json::Value>>,
    #[serde(rename = "connector_certification_scope", skip_serializing_if = "Option::is_none")]
    pub connector_certification_scope: Option<String>,
}

impl EntitlementLimits {
    pub fn new() -> EntitlementLimits {
        EntitlementLimits {
            monthly_launches: None,
            concurrent_runs: None,
            retention_days: None,
            max_cloud_targets: None,
            evidence_export_mb: None,
            connector_certification_scope: 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct FrameworkAdapter {
    #[serde(rename = "apiVersion", skip_serializing_if = "Option::is_none")]
    pub api_version: Option<String>,
    #[serde(rename = "kind", skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")]
    pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "match", skip_serializing_if = "Option::is_none")]
    pub r#match: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "capabilities", default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<Option<serde_json::Value>>,
    #[serde(rename = "entrypoints", skip_serializing_if = "Option::is_none")]
    pub entrypoints: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "build", skip_serializing_if = "Option::is_none")]
    pub build: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl FrameworkAdapter {
    pub fn new() -> FrameworkAdapter {
        FrameworkAdapter {
            api_version: None,
            kind: None,
            metadata: None,
            r#match: None,
            capabilities: None,
            entrypoints: None,
            build: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct GeneratedAppSpecCandidate {
    #[serde(rename = "candidate_id")]
    pub candidate_id: String,
    #[serde(rename = "trusted")]
    pub trusted: bool,
    #[serde(rename = "app_spec")]
    pub app_spec: Box<LaunchpadApp>,
    #[serde(rename = "promotion_requirements")]
    pub promotion_requirements: Vec<String>,
}

impl GeneratedAppSpecCandidate {
    pub fn new(candidate_id: String, trusted: bool, app_spec: LaunchpadApp, promotion_requirements: Vec<String>) -> GeneratedAppSpecCandidate {
        GeneratedAppSpecCandidate {
            candidate_id,
            trusted,
            app_spec: Box::new(app_spec),
            promotion_requirements,
        }
    }
}

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


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

impl GetLaunchpadImport200Response {
    pub fn new(import: LaunchpadImportRecord) -> GetLaunchpadImport200Response {
        GetLaunchpadImport200Response {
            import: Box::new(import),
        }
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct GetLaunchpadMatrix200Response {
    #[serde(rename = "matrix")]
    pub matrix: Vec<LaunchpadMatrixCell>,
}

impl GetLaunchpadMatrix200Response {
    pub fn new(matrix: Vec<LaunchpadMatrixCell>) -> GetLaunchpadMatrix200Response {
        GetLaunchpadMatrix200Response {
            matrix,
        }
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroundedActionRef {
    #[serde(rename = "grounded_action_id")]
    pub grounded_action_id: String,
    #[serde(rename = "screenshot_hash")]
    pub screenshot_hash: String,
    #[serde(rename = "dom_or_ax_snapshot_hash")]
    pub dom_or_ax_snapshot_hash: String,
    #[serde(rename = "target_ref")]
    pub target_ref: String,
    #[serde(rename = "bbox_or_element_id")]
    pub bbox_or_element_id: String,
    #[serde(rename = "action_type")]
    pub action_type: GroundedActionRefActionType,
    #[serde(rename = "precondition")]
    pub precondition: String,
    #[serde(rename = "postcondition")]
    pub postcondition: String,
    #[serde(rename = "postcondition_ref")]
    pub postcondition_ref: String,
    #[serde(rename = "verification_scope_ref")]
    pub verification_scope_ref: String,
    #[serde(rename = "policy_hash")]
    pub policy_hash: String,
    #[serde(rename = "proof_graph_node_ref")]
    pub proof_graph_node_ref: String,
    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
    pub sandbox_grant_hash: Option<String>,
    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(rename = "grounding_hash", skip_serializing_if = "Option::is_none")]
    pub grounding_hash: Option<String>,
}

impl GroundedActionRef {
    pub fn new(grounded_action_id: String, screenshot_hash: String, dom_or_ax_snapshot_hash: String, target_ref: String, bbox_or_element_id: String, action_type: GroundedActionRefActionType, precondition: String, postcondition: String, postcondition_ref: String, verification_scope_ref: String, policy_hash: String, proof_graph_node_ref: String) -> GroundedActionRef {
        GroundedActionRef {
            grounded_action_id,
            screenshot_hash,
            dom_or_ax_snapshot_hash,
            target_ref,
            bbox_or_element_id,
            action_type,
            precondition,
            postcondition,
            postcondition_ref,
            verification_scope_ref,
            policy_hash,
            proof_graph_node_ref,
            sandbox_grant_hash: None,
            created_at: None,
            grounding_hash: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum GroundedActionRefActionType {
    #[serde(rename = "click")]
    Click,
    #[serde(rename = "type")]
    Type,
    #[serde(rename = "select")]
    Select,
    #[serde(rename = "submit")]
    Submit,
    #[serde(rename = "navigate")]
    Navigate,
}

impl Default for GroundedActionRefActionType {
    fn default() -> GroundedActionRefActionType {
        Self::Click
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct GuiActionReceipt {
    #[serde(rename = "receipt_id")]
    pub receipt_id: String,
    #[serde(rename = "grounded_action_ref")]
    pub grounded_action_ref: String,
    #[serde(rename = "screenshot_hash")]
    pub screenshot_hash: String,
    #[serde(rename = "dom_or_ax_snapshot_hash")]
    pub dom_or_ax_snapshot_hash: String,
    #[serde(rename = "target_ref")]
    pub target_ref: String,
    #[serde(rename = "bbox_or_element_id")]
    pub bbox_or_element_id: String,
    #[serde(rename = "action_type")]
    pub action_type: GuiActionReceiptActionType,
    #[serde(rename = "precondition")]
    pub precondition: String,
    #[serde(rename = "postcondition")]
    pub postcondition: String,
    #[serde(rename = "postcondition_ref")]
    pub postcondition_ref: String,
    #[serde(rename = "postcondition_verified")]
    pub postcondition_verified: bool,
    #[serde(rename = "verification_scope_ref")]
    pub verification_scope_ref: String,
    #[serde(rename = "policy_hash")]
    pub policy_hash: String,
    #[serde(rename = "proof_graph_node_ref")]
    pub proof_graph_node_ref: String,
    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
    pub sandbox_grant_hash: Option<String>,
    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(rename = "receipt_hash", skip_serializing_if = "Option::is_none")]
    pub receipt_hash: Option<String>,
}

impl GuiActionReceipt {
    pub fn new(receipt_id: String, grounded_action_ref: String, screenshot_hash: String, dom_or_ax_snapshot_hash: String, target_ref: String, bbox_or_element_id: String, action_type: GuiActionReceiptActionType, precondition: String, postcondition: String, postcondition_ref: String, postcondition_verified: bool, verification_scope_ref: String, policy_hash: String, proof_graph_node_ref: String) -> GuiActionReceipt {
        GuiActionReceipt {
            receipt_id,
            grounded_action_ref,
            screenshot_hash,
            dom_or_ax_snapshot_hash,
            target_ref,
            bbox_or_element_id,
            action_type,
            precondition,
            postcondition,
            postcondition_ref,
            postcondition_verified,
            verification_scope_ref,
            policy_hash,
            proof_graph_node_ref,
            sandbox_grant_hash: None,
            created_at: None,
            receipt_hash: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum GuiActionReceiptActionType {
    #[serde(rename = "click")]
    Click,
    #[serde(rename = "type")]
    Type,
    #[serde(rename = "select")]
    Select,
    #[serde(rename = "submit")]
    Submit,
    #[serde(rename = "navigate")]
    Navigate,
}

impl Default for GuiActionReceiptActionType {
    fn default() -> GuiActionReceiptActionType {
        Self::Click
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct HarnessChangeContract {
    #[serde(rename = "change_contract_id")]
    pub change_contract_id: String,
    #[serde(rename = "component_modified")]
    pub component_modified: HarnessChangeContractComponentModified,
    #[serde(rename = "failure_mode_targeted")]
    pub failure_mode_targeted: String,
    #[serde(rename = "predicted_improvement")]
    pub predicted_improvement: String,
    #[serde(rename = "invariants_preserved")]
    pub invariants_preserved: Vec<String>,
    #[serde(rename = "safety_properties")]
    pub safety_properties: Vec<String>,
    #[serde(rename = "regression_suite_refs")]
    pub regression_suite_refs: Vec<String>,
    #[serde(rename = "simulation_evidence_refs", skip_serializing_if = "Option::is_none")]
    pub simulation_evidence_refs: Option<Vec<String>>,
    #[serde(rename = "canary_scope", skip_serializing_if = "Option::is_none")]
    pub canary_scope: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "rollback_plan")]
    pub rollback_plan: std::collections::HashMap<String, serde_json::Value>,
    #[serde(rename = "approval_required")]
    pub approval_required: bool,
    #[serde(rename = "activation_receipt_ref", skip_serializing_if = "Option::is_none")]
    pub activation_receipt_ref: Option<String>,
    #[serde(rename = "created_at")]
    pub created_at: String,
    #[serde(rename = "contract_hash", skip_serializing_if = "Option::is_none")]
    pub contract_hash: Option<String>,
}

impl HarnessChangeContract {
    pub fn new(change_contract_id: String, component_modified: HarnessChangeContractComponentModified, failure_mode_targeted: String, predicted_improvement: String, invariants_preserved: Vec<String>, safety_properties: Vec<String>, regression_suite_refs: Vec<String>, rollback_plan: std::collections::HashMap<String, serde_json::Value>, approval_required: bool, created_at: String) -> HarnessChangeContract {
        HarnessChangeContract {
            change_contract_id,
            component_modified,
            failure_mode_targeted,
            predicted_improvement,
            invariants_preserved,
            safety_properties,
            regression_suite_refs,
            simulation_evidence_refs: None,
            canary_scope: None,
            rollback_plan,
            approval_required,
            activation_receipt_ref: None,
            created_at,
            contract_hash: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum HarnessChangeContractComponentModified {
    #[serde(rename = "connector_contract")]
    ConnectorContract,
    #[serde(rename = "tool_schema")]
    ToolSchema,
    #[serde(rename = "sandbox_grant")]
    SandboxGrant,
    #[serde(rename = "mcp_approval")]
    McpApproval,
    #[serde(rename = "policy_overlay")]
    PolicyOverlay,
    #[serde(rename = "verifier")]
    Verifier,
    #[serde(rename = "evidence_template")]
    EvidenceTemplate,
    #[serde(rename = "routing_rule")]
    RoutingRule,
}

impl Default for HarnessChangeContractComponentModified {
    fn default() -> HarnessChangeContractComponentModified {
        Self::ConnectorContract
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct HarnessTrace {
    #[serde(rename = "trace_id")]
    pub trace_id: String,
    #[serde(rename = "plan_hash")]
    pub plan_hash: String,
    #[serde(rename = "context_refs", skip_serializing_if = "Option::is_none")]
    pub context_refs: Option<Vec<String>>,
    #[serde(rename = "memory_reads", skip_serializing_if = "Option::is_none")]
    pub memory_reads: Option<Vec<String>>,
    #[serde(rename = "memory_writes", skip_serializing_if = "Option::is_none")]
    pub memory_writes: Option<Vec<String>>,
    #[serde(rename = "tool_schema_hashes", skip_serializing_if = "Option::is_none")]
    pub tool_schema_hashes: Option<Vec<String>>,
    #[serde(rename = "permission_requests", skip_serializing_if = "Option::is_none")]
    pub permission_requests: Option<Vec<String>>,
    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
    pub sandbox_grant_hash: Option<String>,
    #[serde(rename = "mcp_approval_ref", skip_serializing_if = "Option::is_none")]
    pub mcp_approval_ref: Option<String>,
    #[serde(rename = "connector_contract_hash", skip_serializing_if = "Option::is_none")]
    pub connector_contract_hash: Option<String>,
    #[serde(rename = "policy_hash")]
    pub policy_hash: String,
    #[serde(rename = "cpi_output_hash", skip_serializing_if = "Option::is_none")]
    pub cpi_output_hash: Option<String>,
    #[serde(rename = "verifier_outputs", skip_serializing_if = "Option::is_none")]
    pub verifier_outputs: Option<Vec<String>>,
    #[serde(rename = "human_interventions", skip_serializing_if = "Option::is_none")]
    pub human_interventions: Option<Vec<String>>,
    #[serde(rename = "state_updates", skip_serializing_if = "Option::is_none")]
    pub state_updates: Option<Vec<String>>,
    #[serde(rename = "receipt_refs")]
    pub receipt_refs: Vec<String>,
    #[serde(rename = "created_at")]
    pub created_at: String,
    #[serde(rename = "trace_hash", skip_serializing_if = "Option::is_none")]
    pub trace_hash: Option<String>,
}

impl HarnessTrace {
    pub fn new(trace_id: String, plan_hash: String, policy_hash: String, receipt_refs: Vec<String>, created_at: String) -> HarnessTrace {
        HarnessTrace {
            trace_id,
            plan_hash,
            context_refs: None,
            memory_reads: None,
            memory_writes: None,
            tool_schema_hashes: None,
            permission_requests: None,
            sandbox_grant_hash: None,
            mcp_approval_ref: None,
            connector_contract_hash: None,
            policy_hash,
            cpi_output_hash: None,
            verifier_outputs: None,
            human_interventions: None,
            state_updates: None,
            receipt_refs,
            created_at,
            trace_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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ImportEvidenceLedger {
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "receipt_refs", skip_serializing_if = "Option::is_none")]
    pub receipt_refs: Option<Vec<String>>,
    #[serde(rename = "evidence_pack_refs", skip_serializing_if = "Option::is_none")]
    pub evidence_pack_refs: Option<Vec<String>>,
    #[serde(rename = "sbom_ref", skip_serializing_if = "Option::is_none")]
    pub sbom_ref: Option<String>,
    #[serde(rename = "vulnerability_scan_ref", skip_serializing_if = "Option::is_none")]
    pub vulnerability_scan_ref: Option<String>,
    #[serde(rename = "provenance_ref", skip_serializing_if = "Option::is_none")]
    pub provenance_ref: Option<String>,
    #[serde(rename = "license_ref", skip_serializing_if = "Option::is_none")]
    pub license_ref: Option<String>,
    #[serde(rename = "policy_refs", skip_serializing_if = "Option::is_none")]
    pub policy_refs: Option<Vec<String>>,
    #[serde(rename = "offline_verify_command", skip_serializing_if = "Option::is_none")]
    pub offline_verify_command: Option<String>,
}

impl ImportEvidenceLedger {
    pub fn new() -> ImportEvidenceLedger {
        ImportEvidenceLedger {
            status: None,
            receipt_refs: None,
            evidence_pack_refs: None,
            sbom_ref: None,
            vulnerability_scan_ref: None,
            provenance_ref: None,
            license_ref: None,
            policy_refs: None,
            offline_verify_command: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ImportPreflightResult {
    #[serde(rename = "import_id")]
    pub import_id: String,
    #[serde(rename = "status")]
    pub status: String,
    #[serde(rename = "checks")]
    pub checks: Vec<PreflightCheck>,
    #[serde(rename = "blocked_reasons", skip_serializing_if = "Option::is_none")]
    pub blocked_reasons: Option<Vec<String>>,
    #[serde(rename = "evidence_ledger")]
    pub evidence_ledger: Box<ImportEvidenceLedger>,
}

impl ImportPreflightResult {
    pub fn new(import_id: String, status: String, checks: Vec<PreflightCheck>, evidence_ledger: ImportEvidenceLedger) -> ImportPreflightResult {
        ImportPreflightResult {
            import_id,
            status,
            checks,
            blocked_reasons: None,
            evidence_ledger: Box::new(evidence_ledger),
        }
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchRecipe {
    #[serde(rename = "import_id")]
    pub import_id: String,
    #[serde(rename = "generated_at", skip_serializing_if = "Option::is_none")]
    pub generated_at: Option<String>,
    #[serde(rename = "detection_order")]
    pub detection_order: Vec<String>,
    #[serde(rename = "build_strategy")]
    pub build_strategy: Box<BuildStrategy>,
    #[serde(rename = "target_plans")]
    pub target_plans: Vec<TargetPlan>,
    #[serde(rename = "generated_app_specs")]
    pub generated_app_specs: Vec<GeneratedAppSpecCandidate>,
    #[serde(rename = "promotion_state")]
    pub promotion_state: String,
    #[serde(rename = "promotion_requirements", skip_serializing_if = "Option::is_none")]
    pub promotion_requirements: Option<Vec<String>>,
    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
    pub cli_equivalent: Option<String>,
}

impl LaunchRecipe {
    pub fn new(import_id: String, detection_order: Vec<String>, build_strategy: BuildStrategy, target_plans: Vec<TargetPlan>, generated_app_specs: Vec<GeneratedAppSpecCandidate>, promotion_state: String) -> LaunchRecipe {
        LaunchRecipe {
            import_id,
            generated_at: None,
            detection_order,
            build_strategy: Box::new(build_strategy),
            target_plans,
            generated_app_specs,
            promotion_state,
            promotion_requirements: None,
            cli_equivalent: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadApp {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
    pub app_id: Option<String>,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "oci_ref", skip_serializing_if = "Option::is_none")]
    pub oci_ref: Option<String>,
    #[serde(rename = "immutable_digest", skip_serializing_if = "Option::is_none")]
    pub immutable_digest: Option<String>,
    #[serde(rename = "oss_supported", skip_serializing_if = "Option::is_none")]
    pub oss_supported: Option<bool>,
    #[serde(rename = "availability", skip_serializing_if = "Option::is_none")]
    pub availability: Option<String>,
    #[serde(rename = "redistribution", skip_serializing_if = "Option::is_none")]
    pub redistribution: Option<String>,
    #[serde(rename = "install_strategy", skip_serializing_if = "Option::is_none")]
    pub install_strategy: Option<String>,
    #[serde(rename = "risk_class", skip_serializing_if = "Option::is_none")]
    pub risk_class: Option<String>,
    #[serde(rename = "blocked_reason", skip_serializing_if = "Option::is_none")]
    pub blocked_reason: Option<String>,
    #[serde(rename = "required_secrets", skip_serializing_if = "Option::is_none")]
    pub required_secrets: Option<Vec<String>>,
    #[serde(rename = "model_gateway_env", skip_serializing_if = "Option::is_none")]
    pub model_gateway_env: Option<Vec<String>>,
    #[serde(rename = "declared_capabilities", skip_serializing_if = "Option::is_none")]
    pub declared_capabilities: Option<Vec<String>>,
    #[serde(rename = "mcp_servers", skip_serializing_if = "Option::is_none")]
    pub mcp_servers: Option<Vec<LaunchpadMcpServer>>,
    #[serde(rename = "filesystem_needs", skip_serializing_if = "Option::is_none")]
    pub filesystem_needs: Option<Vec<String>>,
    #[serde(rename = "network_needs", skip_serializing_if = "Option::is_none")]
    pub network_needs: Option<Vec<String>>,
    #[serde(rename = "healthcheck", skip_serializing_if = "Option::is_none")]
    pub healthcheck: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "teardown_recipe", skip_serializing_if = "Option::is_none")]
    pub teardown_recipe: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "evidence_profile", skip_serializing_if = "Option::is_none")]
    pub evidence_profile: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "policy_ref", skip_serializing_if = "Option::is_none")]
    pub policy_ref: Option<String>,
    #[serde(rename = "user_state", skip_serializing_if = "Option::is_none")]
    pub user_state: Option<String>,
    #[serde(rename = "required_capability", skip_serializing_if = "Option::is_none")]
    pub required_capability: Option<String>,
    #[serde(rename = "upgrade_reason", skip_serializing_if = "Option::is_none")]
    pub upgrade_reason: Option<String>,
    #[serde(rename = "entitlement_decision", skip_serializing_if = "Option::is_none")]
    pub entitlement_decision: Option<Box<EntitlementDecision>>,
    #[serde(rename = "action_states", skip_serializing_if = "Option::is_none")]
    pub action_states: Option<std::collections::HashMap<String, EntitlementDecision>>,
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<Box<LaunchpadAppStatus>>,
}

impl LaunchpadApp {
    pub fn new(id: String, name: String) -> LaunchpadApp {
        LaunchpadApp {
            id,
            app_id: None,
            name,
            version: None,
            oci_ref: None,
            immutable_digest: None,
            oss_supported: None,
            availability: None,
            redistribution: None,
            install_strategy: None,
            risk_class: None,
            blocked_reason: None,
            required_secrets: None,
            model_gateway_env: None,
            declared_capabilities: None,
            mcp_servers: None,
            filesystem_needs: None,
            network_needs: None,
            healthcheck: None,
            teardown_recipe: None,
            evidence_profile: None,
            policy_ref: None,
            user_state: None,
            required_capability: None,
            upgrade_reason: None,
            entitlement_decision: None,
            action_states: None,
            status: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadAppStatus {
    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
    pub state: 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 = "human_summary", skip_serializing_if = "Option::is_none")]
    pub human_summary: Option<String>,
    #[serde(rename = "missing_secrets", skip_serializing_if = "Option::is_none")]
    pub missing_secrets: Option<Vec<String>>,
    #[serde(rename = "quarantined_mcp", skip_serializing_if = "Option::is_none")]
    pub quarantined_mcp: Option<i32>,
    #[serde(rename = "last_run_id", skip_serializing_if = "Option::is_none")]
    pub last_run_id: Option<String>,
    #[serde(rename = "last_evidencepack_ref", skip_serializing_if = "Option::is_none")]
    pub last_evidencepack_ref: Option<String>,
    #[serde(rename = "proof_status", skip_serializing_if = "Option::is_none")]
    pub proof_status: Option<String>,
}

impl LaunchpadAppStatus {
    pub fn new() -> LaunchpadAppStatus {
        LaunchpadAppStatus {
            state: None,
            verdict: None,
            reason_code: None,
            human_summary: None,
            missing_secrets: None,
            quarantined_mcp: None,
            last_run_id: None,
            last_evidencepack_ref: None,
            proof_status: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl LaunchpadFixAction {
    pub fn new() -> LaunchpadFixAction {
        LaunchpadFixAction {
            label: None,
            cli: None,
            description: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadGateResult {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "group")]
    pub group: String,
    #[serde(rename = "label")]
    pub label: String,
    #[serde(rename = "verdict")]
    pub verdict: String,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
    pub receipt_ref: Option<String>,
    #[serde(rename = "proofgraph_node", skip_serializing_if = "Option::is_none")]
    pub proofgraph_node: Option<String>,
    #[serde(rename = "evidence_refs", skip_serializing_if = "Option::is_none")]
    pub evidence_refs: Option<Vec<String>>,
    #[serde(rename = "summary", skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
    #[serde(rename = "why", skip_serializing_if = "Option::is_none")]
    pub why: Option<String>,
    #[serde(rename = "proof_status")]
    pub proof_status: String,
    #[serde(rename = "raw_detail_ref", skip_serializing_if = "Option::is_none")]
    pub raw_detail_ref: Option<String>,
    #[serde(rename = "raw_proof_ref", skip_serializing_if = "Option::is_none")]
    pub raw_proof_ref: Option<String>,
    #[serde(rename = "receipt_required", skip_serializing_if = "Option::is_none")]
    pub receipt_required: Option<bool>,
    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
    pub cli_equivalent: Option<String>,
    #[serde(rename = "fix_actions", skip_serializing_if = "Option::is_none")]
    pub fix_actions: Option<Vec<LaunchpadFixAction>>,
}

impl LaunchpadGateResult {
    pub fn new(id: String, group: String, label: String, verdict: String, proof_status: String) -> LaunchpadGateResult {
        LaunchpadGateResult {
            id,
            group,
            label,
            verdict,
            reason_code: None,
            receipt_ref: None,
            proofgraph_node: None,
            evidence_refs: None,
            summary: None,
            why: None,
            proof_status,
            raw_detail_ref: None,
            raw_proof_ref: None,
            receipt_required: None,
            cli_equivalent: None,
            fix_actions: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadImportRecord {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "state")]
    pub state: LaunchpadImportRecordState,
    #[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>,
    #[serde(rename = "request")]
    pub request: Box<LaunchpadImportRequest>,
    #[serde(rename = "source_snapshot")]
    pub source_snapshot: Box<SourceSnapshot>,
    #[serde(rename = "capability_graph")]
    pub capability_graph: Box<CapabilityGraph>,
    #[serde(rename = "launch_recipe")]
    pub launch_recipe: Box<LaunchRecipe>,
    #[serde(rename = "preflight", skip_serializing_if = "Option::is_none")]
    pub preflight: Option<Box<ImportPreflightResult>>,
    #[serde(rename = "evidence_ledger")]
    pub evidence_ledger: Box<ImportEvidenceLedger>,
}

impl LaunchpadImportRecord {
    pub fn new(id: String, state: LaunchpadImportRecordState, request: LaunchpadImportRequest, source_snapshot: SourceSnapshot, capability_graph: CapabilityGraph, launch_recipe: LaunchRecipe, evidence_ledger: ImportEvidenceLedger) -> LaunchpadImportRecord {
        LaunchpadImportRecord {
            id,
            state,
            created_at: None,
            updated_at: None,
            request: Box::new(request),
            source_snapshot: Box::new(source_snapshot),
            capability_graph: Box::new(capability_graph),
            launch_recipe: Box::new(launch_recipe),
            preflight: None,
            evidence_ledger: Box::new(evidence_ledger),
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum LaunchpadImportRecordState {
    #[serde(rename = "IMPORTED")]
    Imported,
    #[serde(rename = "PREFLIGHTED")]
    Preflighted,
    #[serde(rename = "PROMOTABLE")]
    Promotable,
    #[serde(rename = "BLOCKED")]
    Blocked,
    #[serde(rename = "LAUNCHED")]
    Launched,
    #[serde(rename = "TORN_DOWN")]
    TornDown,
}

impl Default for LaunchpadImportRecordState {
    fn default() -> LaunchpadImportRecordState {
        Self::Imported
    }
}

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


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

impl LaunchpadImportRequest {
    pub fn new(repo_url: String) -> LaunchpadImportRequest {
        LaunchpadImportRequest {
            repo_url,
            r#ref: None,
            desired_target: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadMatrixCell {
    #[serde(rename = "app_id")]
    pub app_id: String,
    #[serde(rename = "substrate_id")]
    pub substrate_id: String,
    #[serde(rename = "launchable")]
    pub launchable: bool,
    #[serde(rename = "verdict")]
    pub verdict: String,
    #[serde(rename = "reason")]
    pub reason: String,
    #[serde(rename = "availability")]
    pub availability: String,
    #[serde(rename = "user_state", skip_serializing_if = "Option::is_none")]
    pub user_state: Option<String>,
    #[serde(rename = "required_capability", skip_serializing_if = "Option::is_none")]
    pub required_capability: Option<String>,
    #[serde(rename = "upgrade_reason", skip_serializing_if = "Option::is_none")]
    pub upgrade_reason: Option<String>,
    #[serde(rename = "entitlement_decision", skip_serializing_if = "Option::is_none")]
    pub entitlement_decision: Option<Box<EntitlementDecision>>,
    #[serde(rename = "action_states", skip_serializing_if = "Option::is_none")]
    pub action_states: Option<std::collections::HashMap<String, EntitlementDecision>>,
}

impl LaunchpadMatrixCell {
    pub fn new(app_id: String, substrate_id: String, launchable: bool, verdict: String, reason: String, availability: String) -> LaunchpadMatrixCell {
        LaunchpadMatrixCell {
            app_id,
            substrate_id,
            launchable,
            verdict,
            reason,
            availability,
            user_state: None,
            required_capability: None,
            upgrade_reason: None,
            entitlement_decision: None,
            action_states: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadMcpServer {
    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "endpoint", skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    #[serde(rename = "transport", skip_serializing_if = "Option::is_none")]
    pub transport: Option<String>,
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "risk_class", skip_serializing_if = "Option::is_none")]
    pub risk_class: Option<String>,
    #[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<String>>,
    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
    pub receipt_ref: Option<String>,
}

impl LaunchpadMcpServer {
    pub fn new() -> LaunchpadMcpServer {
        LaunchpadMcpServer {
            id: None,
            endpoint: None,
            transport: None,
            status: None,
            risk_class: None,
            tools: None,
            receipt_ref: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl LaunchpadPlanRequest {
    pub fn new(app_id: String, substrate_id: String) -> LaunchpadPlanRequest {
        LaunchpadPlanRequest {
            app_id,
            substrate_id,
            principal: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadPlanResponse {
    #[serde(rename = "launch_id", skip_serializing_if = "Option::is_none")]
    pub launch_id: Option<String>,
    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
    pub app_id: Option<String>,
    #[serde(rename = "substrate_id", skip_serializing_if = "Option::is_none")]
    pub substrate_id: Option<String>,
    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(rename = "kernel_verdict", skip_serializing_if = "Option::is_none")]
    pub kernel_verdict: Option<String>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "plan_hash", skip_serializing_if = "Option::is_none")]
    pub plan_hash: Option<String>,
    #[serde(rename = "user_state", skip_serializing_if = "Option::is_none")]
    pub user_state: Option<String>,
    #[serde(rename = "required_capability", skip_serializing_if = "Option::is_none")]
    pub required_capability: Option<String>,
    #[serde(rename = "upgrade_reason", skip_serializing_if = "Option::is_none")]
    pub upgrade_reason: Option<String>,
    #[serde(rename = "entitlement_decision", skip_serializing_if = "Option::is_none")]
    pub entitlement_decision: Option<Box<EntitlementDecision>>,
    #[serde(rename = "action_states", skip_serializing_if = "Option::is_none")]
    pub action_states: Option<std::collections::HashMap<String, EntitlementDecision>>,
}

impl LaunchpadPlanResponse {
    pub fn new() -> LaunchpadPlanResponse {
        LaunchpadPlanResponse {
            launch_id: None,
            app_id: None,
            substrate_id: None,
            state: None,
            kernel_verdict: None,
            reason: None,
            reason_code: None,
            plan_hash: None,
            user_state: None,
            required_capability: None,
            upgrade_reason: None,
            entitlement_decision: None,
            action_states: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadPolicySimulation {
    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
    pub app_id: 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 = "plain_english", skip_serializing_if = "Option::is_none")]
    pub plain_english: Option<String>,
    #[serde(rename = "structured", skip_serializing_if = "Option::is_none")]
    pub structured: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "diff", skip_serializing_if = "Option::is_none")]
    pub diff: Option<Vec<String>>,
    #[serde(rename = "raw", skip_serializing_if = "Option::is_none")]
    pub raw: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
    pub receipt_ref: Option<String>,
    #[serde(rename = "proof_status", skip_serializing_if = "Option::is_none")]
    pub proof_status: Option<String>,
    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
    pub cli_equivalent: Option<String>,
    #[serde(rename = "fix_actions", skip_serializing_if = "Option::is_none")]
    pub fix_actions: Option<Vec<LaunchpadFixAction>>,
}

impl LaunchpadPolicySimulation {
    pub fn new() -> LaunchpadPolicySimulation {
        LaunchpadPolicySimulation {
            app_id: None,
            verdict: None,
            reason_code: None,
            plain_english: None,
            structured: None,
            diff: None,
            raw: None,
            receipt_ref: None,
            proof_status: None,
            cli_equivalent: None,
            fix_actions: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadRun {
    #[serde(rename = "launch_id", skip_serializing_if = "Option::is_none")]
    pub launch_id: Option<String>,
    #[serde(rename = "run_id", skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
    pub app_id: Option<String>,
    #[serde(rename = "substrate_id", skip_serializing_if = "Option::is_none")]
    pub substrate_id: Option<String>,
    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(rename = "kernel_verdict", skip_serializing_if = "Option::is_none")]
    pub kernel_verdict: Option<String>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "plan_hash", skip_serializing_if = "Option::is_none")]
    pub plan_hash: Option<String>,
    #[serde(rename = "launchplan_hash", skip_serializing_if = "Option::is_none")]
    pub launchplan_hash: Option<String>,
    #[serde(rename = "install_receipt_ref", skip_serializing_if = "Option::is_none")]
    pub install_receipt_ref: Option<String>,
    #[serde(rename = "launch_receipt_ref", skip_serializing_if = "Option::is_none")]
    pub launch_receipt_ref: Option<String>,
    #[serde(rename = "health_receipt_ref", skip_serializing_if = "Option::is_none")]
    pub health_receipt_ref: Option<String>,
    #[serde(rename = "teardown_receipt_ref", skip_serializing_if = "Option::is_none")]
    pub teardown_receipt_ref: Option<String>,
    #[serde(rename = "evidence_pack_refs", skip_serializing_if = "Option::is_none")]
    pub evidence_pack_refs: Option<Vec<String>>,
    #[serde(rename = "secret_grant_refs", skip_serializing_if = "Option::is_none")]
    pub secret_grant_refs: Option<Vec<String>>,
    #[serde(rename = "start_receipt_refs", skip_serializing_if = "Option::is_none")]
    pub start_receipt_refs: Option<Vec<String>>,
    #[serde(rename = "verification_command", skip_serializing_if = "Option::is_none")]
    pub verification_command: Option<String>,
    #[serde(rename = "teardown_command", skip_serializing_if = "Option::is_none")]
    pub teardown_command: Option<String>,
    #[serde(rename = "runtime_handles", skip_serializing_if = "Option::is_none")]
    pub runtime_handles: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl LaunchpadRun {
    pub fn new() -> LaunchpadRun {
        LaunchpadRun {
            launch_id: None,
            run_id: None,
            app_id: None,
            substrate_id: None,
            state: None,
            kernel_verdict: None,
            reason: None,
            reason_code: None,
            plan_hash: None,
            launchplan_hash: None,
            install_receipt_ref: None,
            launch_receipt_ref: None,
            health_receipt_ref: None,
            teardown_receipt_ref: None,
            evidence_pack_refs: None,
            secret_grant_refs: None,
            start_receipt_refs: None,
            verification_command: None,
            teardown_command: None,
            runtime_handles: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadRunDetail {
    #[serde(rename = "run")]
    pub run: Box<LaunchpadRun>,
    #[serde(rename = "app", skip_serializing_if = "Option::is_none")]
    pub app: Option<Box<LaunchpadApp>>,
    #[serde(rename = "instance")]
    pub instance: Box<LaunchpadRuntimeInstance>,
    #[serde(rename = "gates")]
    pub gates: Vec<LaunchpadGateResult>,
    #[serde(rename = "events")]
    pub events: Vec<LaunchpadRunEvent>,
    #[serde(rename = "offline_verification", skip_serializing_if = "Option::is_none")]
    pub offline_verification: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl LaunchpadRunDetail {
    pub fn new(run: LaunchpadRun, instance: LaunchpadRuntimeInstance, gates: Vec<LaunchpadGateResult>, events: Vec<LaunchpadRunEvent>) -> LaunchpadRunDetail {
        LaunchpadRunDetail {
            run: Box::new(run),
            app: None,
            instance: Box::new(instance),
            gates,
            events,
            offline_verification: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadRunEvent {
    #[serde(rename = "run_id")]
    pub run_id: String,
    #[serde(rename = "stage")]
    pub stage: String,
    #[serde(rename = "verdict")]
    pub verdict: String,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
    pub receipt_ref: Option<String>,
    #[serde(rename = "proofgraph_node", skip_serializing_if = "Option::is_none")]
    pub proofgraph_node: Option<String>,
    #[serde(rename = "evidence_refs", skip_serializing_if = "Option::is_none")]
    pub evidence_refs: Option<Vec<String>>,
    #[serde(rename = "raw_payload_ref", skip_serializing_if = "Option::is_none")]
    pub raw_payload_ref: Option<String>,
    #[serde(rename = "human_summary", skip_serializing_if = "Option::is_none")]
    pub human_summary: Option<String>,
    #[serde(rename = "why", skip_serializing_if = "Option::is_none")]
    pub why: Option<String>,
    #[serde(rename = "proof_status")]
    pub proof_status: String,
    #[serde(rename = "receipt_required", skip_serializing_if = "Option::is_none")]
    pub receipt_required: Option<bool>,
    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
    pub cli_equivalent: Option<String>,
    #[serde(rename = "fix_actions", skip_serializing_if = "Option::is_none")]
    pub fix_actions: Option<Vec<LaunchpadFixAction>>,
    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

impl LaunchpadRunEvent {
    pub fn new(run_id: String, stage: String, verdict: String, proof_status: String) -> LaunchpadRunEvent {
        LaunchpadRunEvent {
            run_id,
            stage,
            verdict,
            reason_code: None,
            receipt_ref: None,
            proofgraph_node: None,
            evidence_refs: None,
            raw_payload_ref: None,
            human_summary: None,
            why: None,
            proof_status,
            receipt_required: None,
            cli_equivalent: None,
            fix_actions: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadRuntimeInstance {
    #[serde(rename = "run_id")]
    pub run_id: String,
    #[serde(rename = "container_id", skip_serializing_if = "Option::is_none")]
    pub container_id: Option<String>,
    #[serde(rename = "launchplan_hash", skip_serializing_if = "Option::is_none")]
    pub launchplan_hash: Option<String>,
    #[serde(rename = "state")]
    pub state: String,
    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
    pub verdict: Option<String>,
    #[serde(rename = "active_grants", skip_serializing_if = "Option::is_none")]
    pub active_grants: Option<Vec<String>>,
    #[serde(rename = "receipt_refs", skip_serializing_if = "Option::is_none")]
    pub receipt_refs: Option<Vec<String>>,
    #[serde(rename = "evidencepack_ref", skip_serializing_if = "Option::is_none")]
    pub evidencepack_ref: Option<String>,
    #[serde(rename = "offline_verify_command", skip_serializing_if = "Option::is_none")]
    pub offline_verify_command: Option<String>,
    #[serde(rename = "teardown_command", skip_serializing_if = "Option::is_none")]
    pub teardown_command: Option<String>,
    #[serde(rename = "sandbox_grant", skip_serializing_if = "Option::is_none")]
    pub sandbox_grant: Option<Box<LaunchpadSandboxGrant>>,
    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
    pub cli_equivalent: Option<String>,
}

impl LaunchpadRuntimeInstance {
    pub fn new(run_id: String, state: String) -> LaunchpadRuntimeInstance {
        LaunchpadRuntimeInstance {
            run_id,
            container_id: None,
            launchplan_hash: None,
            state,
            verdict: None,
            active_grants: None,
            receipt_refs: None,
            evidencepack_ref: None,
            offline_verify_command: None,
            teardown_command: None,
            sandbox_grant: None,
            cli_equivalent: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadSandboxGrant {
    #[serde(rename = "backend_profile", skip_serializing_if = "Option::is_none")]
    pub backend_profile: Option<String>,
    #[serde(rename = "runtime", skip_serializing_if = "Option::is_none")]
    pub runtime: Option<String>,
    #[serde(rename = "runtime_version", skip_serializing_if = "Option::is_none")]
    pub runtime_version: Option<String>,
    #[serde(rename = "image_digest", skip_serializing_if = "Option::is_none")]
    pub image_digest: Option<String>,
    #[serde(rename = "filesystem_preopens", skip_serializing_if = "Option::is_none")]
    pub filesystem_preopens: Option<Vec<String>>,
    #[serde(rename = "network_policy", skip_serializing_if = "Option::is_none")]
    pub network_policy: Option<Vec<String>>,
    #[serde(rename = "env", skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<String>>,
    #[serde(rename = "resource_limits", skip_serializing_if = "Option::is_none")]
    pub resource_limits: Option<std::collections::HashMap<String, 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>,
    #[serde(rename = "proof_status", skip_serializing_if = "Option::is_none")]
    pub proof_status: Option<String>,
}

impl LaunchpadSandboxGrant {
    pub fn new() -> LaunchpadSandboxGrant {
        LaunchpadSandboxGrant {
            backend_profile: None,
            runtime: None,
            runtime_version: None,
            image_digest: None,
            filesystem_preopens: None,
            network_policy: None,
            env: None,
            resource_limits: None,
            policy_epoch: None,
            grant_hash: None,
            proof_status: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadSecretGrant {
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "required", skip_serializing_if = "Option::is_none")]
    pub required: Option<bool>,
    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(rename = "scope", skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
    #[serde(rename = "status")]
    pub status: String,
    #[serde(rename = "launch_impact", skip_serializing_if = "Option::is_none")]
    pub launch_impact: Option<String>,
    #[serde(rename = "grant_ref", skip_serializing_if = "Option::is_none")]
    pub grant_ref: Option<String>,
    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
    pub receipt_ref: Option<String>,
    #[serde(rename = "value_env", skip_serializing_if = "Option::is_none")]
    pub value_env: Option<String>,
}

impl LaunchpadSecretGrant {
    pub fn new(name: String, status: String) -> LaunchpadSecretGrant {
        LaunchpadSecretGrant {
            name,
            required: None,
            provider: None,
            scope: None,
            status,
            launch_impact: None,
            grant_ref: None,
            receipt_ref: None,
            value_env: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LaunchpadSubstrate {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "kind", skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(rename = "availability", skip_serializing_if = "Option::is_none")]
    pub availability: Option<String>,
    #[serde(rename = "default_dry_run", skip_serializing_if = "Option::is_none")]
    pub default_dry_run: Option<bool>,
    #[serde(rename = "blocked_reason", skip_serializing_if = "Option::is_none")]
    pub blocked_reason: Option<String>,
}

impl LaunchpadSubstrate {
    pub fn new(id: String, name: String) -> LaunchpadSubstrate {
        LaunchpadSubstrate {
            id,
            name,
            kind: None,
            availability: None,
            default_dry_run: None,
            blocked_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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ListLaunchpadApps200Response {
    #[serde(rename = "apps")]
    pub apps: Vec<LaunchpadApp>,
}

impl ListLaunchpadApps200Response {
    pub fn new(apps: Vec<LaunchpadApp>) -> ListLaunchpadApps200Response {
        ListLaunchpadApps200Response {
            apps,
        }
    }
}

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


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

impl ListLaunchpadImports200Response {
    pub fn new(imports: Vec<LaunchpadImportRecord>) -> ListLaunchpadImports200Response {
        ListLaunchpadImports200Response {
            imports,
            cli_equivalent: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


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

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ListLaunchpadRuns200Response {
    #[serde(rename = "runs", skip_serializing_if = "Option::is_none")]
    pub runs: Option<Vec<LaunchpadRun>>,
    #[serde(rename = "instances", skip_serializing_if = "Option::is_none")]
    pub instances: Option<Vec<LaunchpadRuntimeInstance>>,
}

impl ListLaunchpadRuns200Response {
    pub fn new() -> ListLaunchpadRuns200Response {
        ListLaunchpadRuns200Response {
            runs: None,
            instances: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


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

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ListLaunchpadSubstrates200Response {
    #[serde(rename = "substrates")]
    pub substrates: Vec<LaunchpadSubstrate>,
}

impl ListLaunchpadSubstrates200Response {
    pub fn new(substrates: Vec<LaunchpadSubstrate>) -> ListLaunchpadSubstrates200Response {
        ListLaunchpadSubstrates200Response {
            substrates,
        }
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LocalConsoleRuntimeConfig {
    #[serde(rename = "api_base_url")]
    pub api_base_url: String,
    #[serde(rename = "local_mode")]
    pub local_mode: bool,
    #[serde(rename = "start_onboarding")]
    pub start_onboarding: bool,
    #[serde(rename = "tenant_id")]
    pub tenant_id: String,
    #[serde(rename = "principal_id")]
    pub principal_id: String,
    #[serde(rename = "profile")]
    pub profile: LocalConsoleRuntimeConfigProfile,
    #[serde(rename = "entitlements")]
    pub entitlements: Vec<LocalConsoleRuntimeConfigEntitlements>,
}

impl LocalConsoleRuntimeConfig {
    pub fn new(api_base_url: String, local_mode: bool, start_onboarding: bool, tenant_id: String, principal_id: String, profile: LocalConsoleRuntimeConfigProfile, entitlements: Vec<LocalConsoleRuntimeConfigEntitlements>) -> LocalConsoleRuntimeConfig {
        LocalConsoleRuntimeConfig {
            api_base_url,
            local_mode,
            start_onboarding,
            tenant_id,
            principal_id,
            profile,
            entitlements,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum LocalConsoleRuntimeConfigProfile {
    #[serde(rename = "claude")]
    Claude,
    #[serde(rename = "codex")]
    Codex,
    #[serde(rename = "mcp")]
    Mcp,
    #[serde(rename = "openai-compatible")]
    OpenaiCompatible,
}

impl Default for LocalConsoleRuntimeConfigProfile {
    fn default() -> LocalConsoleRuntimeConfigProfile {
        Self::Claude
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum LocalConsoleRuntimeConfigEntitlements {
    #[serde(rename = "OSS_CORE")]
    OssCore,
}

impl Default for LocalConsoleRuntimeConfigEntitlements {
    fn default() -> LocalConsoleRuntimeConfigEntitlements {
        Self::OssCore
    }
}

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


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

impl LocalSessionExchangeRequest {
    pub fn new(token: String) -> LocalSessionExchangeRequest {
        LocalSessionExchangeRequest {
            token,
        }
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct LocalSessionExchangeResponse {
    #[serde(rename = "session_token")]
    pub session_token: String,
    #[serde(rename = "tenant_id")]
    pub tenant_id: String,
    #[serde(rename = "principal_id")]
    pub principal_id: String,
    #[serde(rename = "principal")]
    pub principal: String,
    #[serde(rename = "expires_at")]
    pub expires_at: String,
    #[serde(rename = "entitlements")]
    pub entitlements: Vec<LocalSessionExchangeResponseEntitlements>,
}

impl LocalSessionExchangeResponse {
    pub fn new(session_token: String, tenant_id: String, principal_id: String, principal: String, expires_at: String, entitlements: Vec<LocalSessionExchangeResponseEntitlements>) -> LocalSessionExchangeResponse {
        LocalSessionExchangeResponse {
            session_token,
            tenant_id,
            principal_id,
            principal,
            expires_at,
            entitlements,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum LocalSessionExchangeResponseEntitlements {
    #[serde(rename = "OSS_CORE")]
    OssCore,
}

impl Default for LocalSessionExchangeResponseEntitlements {
    fn default() -> LocalSessionExchangeResponseEntitlements {
        Self::OssCore
    }
}

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


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

impl OAuthRequirement {
    pub fn new() -> OAuthRequirement {
        OAuthRequirement {
            provider: None,
            scopes: None,
            source: None,
        }
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OnboardingEvidenceExport {
    #[serde(rename = "evidence_pack_ref")]
    pub evidence_pack_ref: String,
    #[serde(rename = "sha256")]
    pub sha256: String,
    #[serde(rename = "receipt_refs")]
    pub receipt_refs: std::collections::HashMap<String, String>,
    #[serde(rename = "steps")]
    pub steps: Vec<OnboardingStep>,
}

impl OnboardingEvidenceExport {
    pub fn new(evidence_pack_ref: String, sha256: String, receipt_refs: std::collections::HashMap<String, String>, steps: Vec<OnboardingStep>) -> OnboardingEvidenceExport {
        OnboardingEvidenceExport {
            evidence_pack_ref,
            sha256,
            receipt_refs,
            steps,
        }
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OnboardingRunStepRequest {
    #[serde(rename = "step_id")]
    pub step_id: OnboardingRunStepRequestStepId,
}

impl OnboardingRunStepRequest {
    pub fn new(step_id: OnboardingRunStepRequestStepId) -> OnboardingRunStepRequest {
        OnboardingRunStepRequest {
            step_id,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum OnboardingRunStepRequestStepId {
    #[serde(rename = "health")]
    Health,
    #[serde(rename = "policy")]
    Policy,
    #[serde(rename = "allow")]
    Allow,
    #[serde(rename = "deny")]
    Deny,
    #[serde(rename = "mcp")]
    Mcp,
    #[serde(rename = "verify")]
    Verify,
}

impl Default for OnboardingRunStepRequestStepId {
    fn default() -> OnboardingRunStepRequestStepId {
        Self::Health
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OnboardingState {
    #[serde(rename = "mode")]
    pub mode: OnboardingStateMode,
    #[serde(rename = "entitlements")]
    pub entitlements: Vec<OnboardingStateEntitlements>,
    #[serde(rename = "profile")]
    pub profile: String,
    #[serde(rename = "policy_path", skip_serializing_if = "Option::is_none")]
    pub policy_path: Option<String>,
    #[serde(rename = "evidence_pack_ref", skip_serializing_if = "Option::is_none")]
    pub evidence_pack_ref: Option<String>,
    #[serde(rename = "steps")]
    pub steps: Vec<OnboardingStep>,
}

impl OnboardingState {
    pub fn new(mode: OnboardingStateMode, entitlements: Vec<OnboardingStateEntitlements>, profile: String, steps: Vec<OnboardingStep>) -> OnboardingState {
        OnboardingState {
            mode,
            entitlements,
            profile,
            policy_path: None,
            evidence_pack_ref: None,
            steps,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum OnboardingStateMode {
    #[serde(rename = "self-hosted-oss")]
    SelfHostedOss,
}

impl Default for OnboardingStateMode {
    fn default() -> OnboardingStateMode {
        Self::SelfHostedOss
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum OnboardingStateEntitlements {
    #[serde(rename = "OSS_CORE")]
    OssCore,
}

impl Default for OnboardingStateEntitlements {
    fn default() -> OnboardingStateEntitlements {
        Self::OssCore
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OnboardingStep {
    #[serde(rename = "id")]
    pub id: OnboardingStepId,
    #[serde(rename = "title")]
    pub title: String,
    #[serde(rename = "description")]
    pub description: String,
    #[serde(rename = "status")]
    pub status: OnboardingStepStatus,
    #[serde(rename = "verdict")]
    pub verdict: OnboardingStepVerdict,
    #[serde(rename = "reason_code")]
    pub reason_code: String,
    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
    pub receipt_ref: Option<String>,
}

impl OnboardingStep {
    pub fn new(id: OnboardingStepId, title: String, description: String, status: OnboardingStepStatus, verdict: OnboardingStepVerdict, reason_code: String) -> OnboardingStep {
        OnboardingStep {
            id,
            title,
            description,
            status,
            verdict,
            reason_code,
            receipt_ref: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum OnboardingStepId {
    #[serde(rename = "health")]
    Health,
    #[serde(rename = "policy")]
    Policy,
    #[serde(rename = "allow")]
    Allow,
    #[serde(rename = "deny")]
    Deny,
    #[serde(rename = "mcp")]
    Mcp,
    #[serde(rename = "verify")]
    Verify,
}

impl Default for OnboardingStepId {
    fn default() -> OnboardingStepId {
        Self::Health
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum OnboardingStepStatus {
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "pass")]
    Pass,
}

impl Default for OnboardingStepStatus {
    fn default() -> OnboardingStepStatus {
        Self::Pending
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum OnboardingStepVerdict {
    #[serde(rename = "ALLOW")]
    Allow,
    #[serde(rename = "DENY")]
    Deny,
    #[serde(rename = "ESCALATE")]
    Escalate,
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PlanTransaction {
    #[serde(rename = "plan_transaction_id")]
    pub plan_transaction_id: String,
    #[serde(rename = "plan_hash")]
    pub plan_hash: String,
    #[serde(rename = "read_set")]
    pub read_set: Vec<String>,
    #[serde(rename = "write_set")]
    pub write_set: Vec<String>,
    #[serde(rename = "assumption_set")]
    pub assumption_set: Vec<String>,
    #[serde(rename = "version_dependencies", skip_serializing_if = "Option::is_none")]
    pub version_dependencies: Option<Vec<String>>,
    #[serde(rename = "verification_obligations")]
    pub verification_obligations: Vec<String>,
    #[serde(rename = "conflict_policy")]
    pub conflict_policy: PlanTransactionConflictPolicy,
    #[serde(rename = "rollback_policy", skip_serializing_if = "Option::is_none")]
    pub rollback_policy: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "rollback_or_compensation_policy", skip_serializing_if = "Option::is_none")]
    pub rollback_or_compensation_policy: Option<String>,
    #[serde(rename = "approval_state", skip_serializing_if = "Option::is_none")]
    pub approval_state: Option<PlanTransactionApprovalState>,
    #[serde(rename = "human_review_state", skip_serializing_if = "Option::is_none")]
    pub human_review_state: Option<String>,
    #[serde(rename = "transaction_hash", skip_serializing_if = "Option::is_none")]
    pub transaction_hash: Option<String>,
}

impl PlanTransaction {
    pub fn new(plan_transaction_id: String, plan_hash: String, read_set: Vec<String>, write_set: Vec<String>, assumption_set: Vec<String>, verification_obligations: Vec<String>, conflict_policy: PlanTransactionConflictPolicy) -> PlanTransaction {
        PlanTransaction {
            plan_transaction_id,
            plan_hash,
            read_set,
            write_set,
            assumption_set,
            version_dependencies: None,
            verification_obligations,
            conflict_policy,
            rollback_policy: None,
            rollback_or_compensation_policy: None,
            approval_state: None,
            human_review_state: None,
            transaction_hash: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum PlanTransactionConflictPolicy {
    #[serde(rename = "deny")]
    Deny,
    #[serde(rename = "escalate")]
    Escalate,
    #[serde(rename = "last_writer_forbidden")]
    LastWriterForbidden,
}

impl Default for PlanTransactionConflictPolicy {
    fn default() -> PlanTransactionConflictPolicy {
        Self::Deny
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum PlanTransactionApprovalState {
    #[serde(rename = "none")]
    None,
    #[serde(rename = "required")]
    Required,
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "denied")]
    Denied,
    #[serde(rename = "expired")]
    Expired,
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PreflightCheck {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "status")]
    pub status: String,
    #[serde(rename = "summary")]
    pub summary: String,
    #[serde(rename = "evidence_ref", skip_serializing_if = "Option::is_none")]
    pub evidence_ref: Option<String>,
    #[serde(rename = "fix_actions", skip_serializing_if = "Option::is_none")]
    pub fix_actions: Option<Vec<String>>,
}

impl PreflightCheck {
    pub fn new(id: String, status: String, summary: String) -> PreflightCheck {
        PreflightCheck {
            id,
            status,
            summary,
            evidence_ref: None,
            fix_actions: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PreflightLaunchpadImport202Response {
    #[serde(rename = "import")]
    pub import: Box<LaunchpadImportRecord>,
    #[serde(rename = "preflight")]
    pub preflight: Box<ImportPreflightResult>,
    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
    pub cli_equivalent: Option<String>,
}

impl PreflightLaunchpadImport202Response {
    pub fn new(import: LaunchpadImportRecord, preflight: ImportPreflightResult) -> PreflightLaunchpadImport202Response {
        PreflightLaunchpadImport202Response {
            import: Box::new(import),
            preflight: Box::new(preflight),
            cli_equivalent: 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.7.5
 *
 * 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>,
    /// Receipt signature profile emitted by the signer. Classical is Ed25519-only; hybrid is Ed25519 plus ML-DSA-65.
    #[serde(rename = "signature_profile", skip_serializing_if = "Option::is_none")]
    pub signature_profile: Option<ReceiptSignatureProfile>,
    /// Signature algorithm or composite algorithm used for this receipt, such as ed25519, Hybrid-Ed25519-MLDSA65, or ml-dsa-65.
    #[serde(rename = "signature_algorithm", skip_serializing_if = "Option::is_none")]
    pub signature_algorithm: Option<String>,
    /// Active signer key identifier used for the receipt signature.
    #[serde(rename = "key_id", skip_serializing_if = "Option::is_none")]
    pub key_id: Option<String>,
    /// Public verification keys keyed by algorithm for the emitted receipt signature.
    #[serde(rename = "public_key_set", skip_serializing_if = "Option::is_none")]
    pub public_key_set: Option<std::collections::HashMap<String, 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,
            signature_profile: None,
            signature_algorithm: None,
            key_id: None,
            public_key_set: None,
            timestamp: None,
            principal: None,
            executor_id: None,
            args_hash: None,
            metadata: None,
        }
    }
}
/// Receipt signature profile emitted by the signer. Classical is Ed25519-only; hybrid is Ed25519 plus ML-DSA-65.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum ReceiptSignatureProfile {
    #[serde(rename = "classical")]
    Classical,
    #[serde(rename = "hybrid")]
    Hybrid,
    #[serde(rename = "pqc")]
    Pqc,
}

impl Default for ReceiptSignatureProfile {
    fn default() -> ReceiptSignatureProfile {
        Self::Classical
    }
}

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SecretContract {
    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    #[serde(rename = "required", skip_serializing_if = "Option::is_none")]
    pub required: Option<bool>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "targets", skip_serializing_if = "Option::is_none")]
    pub targets: Option<Vec<String>>,
}

impl SecretContract {
    pub fn new() -> SecretContract {
        SecretContract {
            name: None,
            source: None,
            required: None,
            reason: None,
            targets: 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SourceFileSummary {
    #[serde(rename = "path")]
    pub path: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "size", skip_serializing_if = "Option::is_none")]
    pub size: Option<i32>,
    #[serde(rename = "sha", skip_serializing_if = "Option::is_none")]
    pub sha: Option<String>,
    #[serde(rename = "language", skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(rename = "content", skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
}

impl SourceFileSummary {
    pub fn new(path: String, kind: String) -> SourceFileSummary {
        SourceFileSummary {
            path,
            kind,
            size: None,
            sha: None,
            language: None,
            content: 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SourceSnapshot {
    #[serde(rename = "repo_url")]
    pub repo_url: String,
    #[serde(rename = "provider")]
    pub provider: String,
    #[serde(rename = "owner", skip_serializing_if = "Option::is_none")]
    pub owner: Option<String>,
    #[serde(rename = "repo", skip_serializing_if = "Option::is_none")]
    pub repo: Option<String>,
    #[serde(rename = "ref", skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<String>,
    #[serde(rename = "commit", skip_serializing_if = "Option::is_none")]
    pub commit: Option<String>,
    #[serde(rename = "license_spdx", skip_serializing_if = "Option::is_none")]
    pub license_spdx: Option<String>,
    #[serde(rename = "license_state")]
    pub license_state: String,
    #[serde(rename = "fetched_at", skip_serializing_if = "Option::is_none")]
    pub fetched_at: Option<String>,
    #[serde(rename = "files")]
    pub files: Vec<SourceFileSummary>,
    #[serde(rename = "api_source", skip_serializing_if = "Option::is_none")]
    pub api_source: Option<String>,
}

impl SourceSnapshot {
    pub fn new(repo_url: String, provider: String, license_state: String, files: Vec<SourceFileSummary>) -> SourceSnapshot {
        SourceSnapshot {
            repo_url,
            provider,
            owner: None,
            repo: None,
            r#ref: None,
            commit: None,
            license_spdx: None,
            license_state,
            fetched_at: None,
            files,
            api_source: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
 *
 * The version of the OpenAPI document: 0.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct TargetPlan {
    #[serde(rename = "target_id")]
    pub target_id: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "substrate_id", skip_serializing_if = "Option::is_none")]
    pub substrate_id: Option<String>,
    #[serde(rename = "deployable")]
    pub deployable: bool,
    #[serde(rename = "requires_approval", skip_serializing_if = "Option::is_none")]
    pub requires_approval: Option<bool>,
    #[serde(rename = "commands", skip_serializing_if = "Option::is_none")]
    pub commands: Option<Vec<Vec<String>>>,
    #[serde(rename = "artifacts", skip_serializing_if = "Option::is_none")]
    pub artifacts: Option<Vec<String>>,
    #[serde(rename = "secrets_backend", skip_serializing_if = "Option::is_none")]
    pub secrets_backend: Option<String>,
    #[serde(rename = "healthcheck", skip_serializing_if = "Option::is_none")]
    pub healthcheck: Option<std::collections::HashMap<String, String>>,
    #[serde(rename = "rollback", skip_serializing_if = "Option::is_none")]
    pub rollback: Option<Vec<String>>,
    #[serde(rename = "risk")]
    pub risk: String,
    #[serde(rename = "reason")]
    pub reason: String,
}

impl TargetPlan {
    pub fn new(target_id: String, kind: String, deployable: bool, risk: String, reason: String) -> TargetPlan {
        TargetPlan {
            target_id,
            kind,
            substrate_id: None,
            deployable,
            requires_approval: None,
            commands: None,
            artifacts: None,
            secrets_backend: None,
            healthcheck: None,
            rollback: None,
            risk,
            reason,
        }
    }
}

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


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

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


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct VerificationScope {
    #[serde(rename = "verification_scope_id")]
    pub verification_scope_id: String,
    #[serde(rename = "subject_hash")]
    pub subject_hash: String,
    #[serde(rename = "risk_class", skip_serializing_if = "Option::is_none")]
    pub risk_class: Option<VerificationScopeRiskClass>,
    #[serde(rename = "checks_performed")]
    pub checks_performed: Vec<String>,
    #[serde(rename = "assumptions", skip_serializing_if = "Option::is_none")]
    pub assumptions: Option<Vec<String>>,
    #[serde(rename = "untested_regions", skip_serializing_if = "Option::is_none")]
    pub untested_regions: Option<Vec<String>>,
    #[serde(rename = "known_limits", skip_serializing_if = "Option::is_none")]
    pub known_limits: Option<Vec<String>>,
    #[serde(rename = "remaining_risks", skip_serializing_if = "Option::is_none")]
    pub remaining_risks: Option<Vec<String>>,
    #[serde(rename = "required_followup", skip_serializing_if = "Option::is_none")]
    pub required_followup: Option<Vec<String>>,
    #[serde(rename = "verifier_hash")]
    pub verifier_hash: String,
    #[serde(rename = "policy_hash")]
    pub policy_hash: String,
    #[serde(rename = "created_at")]
    pub created_at: String,
    #[serde(rename = "scope_hash", skip_serializing_if = "Option::is_none")]
    pub scope_hash: Option<String>,
}

impl VerificationScope {
    pub fn new(verification_scope_id: String, subject_hash: String, checks_performed: Vec<String>, verifier_hash: String, policy_hash: String, created_at: String) -> VerificationScope {
        VerificationScope {
            verification_scope_id,
            subject_hash,
            risk_class: None,
            checks_performed,
            assumptions: None,
            untested_regions: None,
            known_limits: None,
            remaining_risks: None,
            required_followup: None,
            verifier_hash,
            policy_hash,
            created_at,
            scope_hash: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum VerificationScopeRiskClass {
    #[serde(rename = "T0")]
    T0,
    #[serde(rename = "T1")]
    T1,
    #[serde(rename = "T2")]
    T2,
    #[serde(rename = "T3")]
    T3,
}

impl Default for VerificationScopeRiskClass {
    fn default() -> VerificationScopeRiskClass {
        Self::T0
    }
}

/*
 * 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.7.5
 *
 * 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.7.5
 *
 * 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.7.5
 *
 * 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;