use serde::{Deserialize, Serialize};
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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_alias", skip_serializing_if = "Option::is_none")]
pub plan_alias: 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_alias: 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 = "individual")]
Individual,
#[serde(rename = "enterprise")]
Enterprise,
}
impl Default for AccountEntitlementsPlan {
fn default() -> AccountEntitlementsPlan {
Self::Free
}
}
#[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_alias", skip_serializing_if = "Option::is_none")]
pub plan_alias: 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_alias: 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 = "individual")]
Individual,
#[serde(rename = "enterprise")]
Enterprise,
}
impl Default for AccountSessionPlan {
fn default() -> AccountSessionPlan {
Self::Free
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApprovalRequest {
#[serde(rename = "intent_hash")]
pub intent_hash: String,
#[serde(rename = "signature_b64")]
pub signature_b64: String,
#[serde(rename = "public_key_b64")]
pub public_key_b64: String,
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BoundaryStatus {
#[serde(rename = "version", skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "status", skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "receipt_store_ready", skip_serializing_if = "Option::is_none")]
pub receipt_store_ready: Option<bool>,
#[serde(rename = "signer_ready", skip_serializing_if = "Option::is_none")]
pub signer_ready: Option<bool>,
#[serde(rename = "open_approvals", skip_serializing_if = "Option::is_none")]
pub open_approvals: Option<i32>,
#[serde(rename = "quarantined_mcp_servers", skip_serializing_if = "Option::is_none")]
pub quarantined_mcp_servers: Option<i32>,
#[serde(rename = "last_checkpoint_id", skip_serializing_if = "Option::is_none")]
pub last_checkpoint_id: Option<String>,
#[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
pub checked_at: Option<String>,
}
impl BoundaryStatus {
pub fn new() -> BoundaryStatus {
BoundaryStatus {
version: None,
status: None,
receipt_store_ready: None,
signer_ready: None,
open_approvals: None,
quarantined_mcp_servers: None,
last_checkpoint_id: None,
checked_at: None,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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
}
}
#[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),
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Effect {
#[serde(rename = "effect_type")]
pub effect_type: String,
#[serde(rename = "effect_id")]
pub effect_id: String,
#[serde(rename = "params")]
pub params: std::collections::HashMap<String, serde_json::Value>,
#[serde(rename = "budget_id", skip_serializing_if = "Option::is_none")]
pub budget_id: Option<String>,
}
impl Effect {
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,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EffectBoundary {
#[serde(rename = "effect")]
pub effect: Box<Effect>,
#[serde(rename = "principal")]
pub principal: String,
#[serde(rename = "context", skip_serializing_if = "Option::is_none")]
pub context: Option<std::collections::HashMap<String, serde_json::Value>>,
}
impl EffectBoundary {
pub fn new(effect: Effect, principal: String) -> EffectBoundary {
EffectBoundary {
effect: Box::new(effect),
principal,
context: None,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EvidenceEnvelopeExportRequest {
#[serde(rename = "manifest_id")]
pub manifest_id: String,
#[serde(rename = "envelope")]
pub envelope: EvidenceEnvelopeExportRequestEnvelope,
#[serde(rename = "native_evidence_hash")]
pub native_evidence_hash: String,
#[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
#[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
}
}
#[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
}
}
#[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,
}
}
}
#[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
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExportRequest {
#[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
}
}
#[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
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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),
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
#[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>>,
#[serde(rename = "active_packs", skip_serializing_if = "Option::is_none")]
pub active_packs: Option<Vec<String>>,
}
impl GovernanceDecision {
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
}
}
#[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 = "verification_scope_ref")]
pub verification_scope_ref: String,
#[serde(rename = "policy_hash")]
pub policy_hash: 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, verification_scope_ref: String, policy_hash: String) -> GroundedActionRef {
GroundedActionRef {
grounded_action_id,
screenshot_hash,
dom_or_ax_snapshot_hash,
target_ref,
bbox_or_element_id,
action_type,
precondition,
postcondition,
verification_scope_ref,
policy_hash,
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
}
}
#[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_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 = "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_verified: bool, verification_scope_ref: String, policy_hash: 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_verified,
verification_scope_ref,
policy_hash,
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
}
}
#[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
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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),
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct HelmErrorError {
#[serde(rename = "message")]
pub message: String,
#[serde(rename = "type")]
pub r#type: HelmErrorErrorType,
#[serde(rename = "code")]
pub code: String,
#[serde(rename = "reason_code")]
pub reason_code: HelmErrorErrorReasonCode,
#[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
}
}
#[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
}
}
#[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,
}
}
}
#[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),
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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,
}
}
}
#[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
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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())
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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())
}
}
#[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
}
}
#[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())
}
}
#[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
}
}
#[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
}
}
#[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,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PdpRequest {
#[serde(rename = "boundary")]
pub boundary: Box<EffectBoundary>,
}
impl PdpRequest {
pub fn new(boundary: EffectBoundary) -> PdpRequest {
PdpRequest {
boundary: Box::new(boundary),
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PdpResponse {
#[serde(rename = "decision")]
pub decision: Box<GovernanceDecision>,
}
impl PdpResponse {
pub fn new(decision: GovernanceDecision) -> PdpResponse {
PdpResponse {
decision: Box::new(decision),
}
}
}
#[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
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PolicyBundle {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "version")]
pub version: String,
#[serde(rename = "content_hash")]
pub content_hash: String,
#[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 {
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
}
}
#[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,
}
}
}
#[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,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Receipt {
#[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
pub receipt_id: Option<String>,
#[serde(rename = "decision_id", skip_serializing_if = "Option::is_none")]
pub decision_id: Option<String>,
#[serde(rename = "effect_id", skip_serializing_if = "Option::is_none")]
pub effect_id: Option<String>,
#[serde(rename = "status", skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
pub reason_code: Option<String>,
#[serde(rename = "output_hash", skip_serializing_if = "Option::is_none")]
pub output_hash: Option<String>,
#[serde(rename = "blob_hash", skip_serializing_if = "Option::is_none")]
pub blob_hash: Option<String>,
#[serde(rename = "prev_hash", skip_serializing_if = "Option::is_none")]
pub prev_hash: Option<String>,
#[serde(rename = "lamport_clock", skip_serializing_if = "Option::is_none")]
pub lamport_clock: Option<i32>,
#[serde(rename = "signature", skip_serializing_if = "Option::is_none")]
pub signature: Option<String>,
#[serde(rename = "timestamp", skip_serializing_if = "Option::is_none")]
pub timestamp: Option<String>,
#[serde(rename = "principal", skip_serializing_if = "Option::is_none")]
pub principal: Option<String>,
#[serde(rename = "executor_id", skip_serializing_if = "Option::is_none")]
pub executor_id: Option<String>,
#[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
pub args_hash: Option<String>,
#[serde(rename = "metadata", skip_serializing_if = "Option::is_none")]
pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
}
impl Receipt {
pub fn new() -> Receipt {
Receipt {
receipt_id: None,
decision_id: None,
effect_id: None,
status: None,
reason_code: None,
output_hash: None,
blob_hash: None,
prev_hash: None,
lamport_clock: None,
signature: None,
timestamp: None,
principal: None,
executor_id: None,
args_hash: None,
metadata: None,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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,
}
}
}
#[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
}
}
#[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
}
}
#[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,
}
}
}
#[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())
}
}
#[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>,
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct TamperPublicDemoReceiptRequest {
#[serde(rename = "receipt")]
pub receipt: Box<Receipt>,
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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,
}
}
}
#[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
}
}
#[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
}
}
#[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,
}
}
}
#[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
}
}
#[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,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct VerifyPublicDemoReceiptRequest {
#[serde(rename = "receipt")]
pub receipt: Box<Receipt>,
#[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,
}
}
}
#[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;