spiral-sdk 0.1.11

// Generated by tools/service-contracts/rust.py. Do not edit.
#![doc = "Generated transport-independent contract objects."]

use std::error::Error as StdError;
use std::fmt::{self, Display, Formatter};

use serde::{Deserialize, Deserializer, Serialize};
use serde_json::Value;
use spiral_contract::error::{ErrorEnvelope, ServiceError};
use spiral_contract::strict::{DeserializeStrict, Strict};
use uuid::Uuid;

/// A public JSON Web Key with a key identifier. Private key material is rejected.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateKeyRequest {
    /// Contract field jwk.
    #[serde(rename = "jwk")]
    pub jwk: Value,
}
impl<'de> DeserializeStrict<'de> for CreateKeyRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "jwk")]
            jwk: Strict<Value>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { jwk: wire.jwk.0 })
    }
}

/// An external issuer and claim conditions trusted by a Workload.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreatePolicyRequest {
    /// Contract field audience.
    #[serde(rename = "audience")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub audience: Option<String>,
    /// Contract field conditions.
    #[serde(rename = "conditions")]
    pub conditions: Vec<PolicyCondition>,
    /// Contract field issuer.
    #[serde(rename = "issuer")]
    pub issuer: String,
    /// Contract field name.
    #[serde(rename = "name")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}
impl<'de> DeserializeStrict<'de> for CreatePolicyRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "audience")]
            #[serde(default)]
            audience: Strict<Option<String>>,
            #[serde(rename = "conditions")]
            conditions: Strict<Vec<PolicyCondition>>,
            #[serde(rename = "issuer")]
            issuer: Strict<String>,
            #[serde(rename = "name")]
            #[serde(default)]
            name: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            audience: wire.audience.0,
            conditions: wire.conditions.0,
            issuer: wire.issuer.0,
            name: wire.name.0,
        })
    }
}

/// Properties for a machine identity.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateWorkloadRequest {
    /// Contract field name.
    #[serde(rename = "name")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}
impl<'de> DeserializeStrict<'de> for CreateWorkloadRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "name")]
            #[serde(default)]
            name: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { name: wire.name.0 })
    }
}

/// A public JSON Web Key whose assertions authenticate the Workload.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Key {
    /// Contract field jwk.
    #[serde(rename = "jwk")]
    pub jwk: Value,
    /// Contract field kid.
    #[serde(rename = "kid")]
    pub kid: String,
    /// Contract field workloadId.
    #[serde(rename = "workloadId")]
    pub workload_id: String,
}
impl<'de> DeserializeStrict<'de> for Key {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "jwk")]
            jwk: Strict<Value>,
            #[serde(rename = "kid")]
            kid: Strict<String>,
            #[serde(rename = "workloadId")]
            workload_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            jwk: wire.jwk.0,
            kid: wire.kid.0,
            workload_id: wire.workload_id.0,
        })
    }
}

/// One live page of Key records, ordered by ID. Continuations expire after one hour and bind the
/// credential, operation, filters and page size.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct KeyPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<Key>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for KeyPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "items")]
            items: Strict<Vec<Key>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            items: wire.items.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// The registered public key.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct KeyResponse {
    /// Contract field key.
    #[serde(rename = "key")]
    pub key: Key,
}
impl<'de> DeserializeStrict<'de> for KeyResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "key")]
            key: Strict<Key>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { key: wire.key.0 })
    }
}

/// Continuation request. Page size defaults to 100 and must be 1..=1000. Keep the same credential,
/// filters and page size when following a continuation.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PageRequest {
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<u32>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for PageRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<u32>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
        })
    }
}

/// A Workload trust policy.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Policy {
    /// Contract field audience.
    #[serde(rename = "audience")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub audience: Option<String>,
    /// Contract field conditions.
    #[serde(rename = "conditions")]
    pub conditions: Vec<PolicyCondition>,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field issuer.
    #[serde(rename = "issuer")]
    pub issuer: String,
    /// Contract field name.
    #[serde(rename = "name")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Contract field workloadId.
    #[serde(rename = "workloadId")]
    pub workload_id: String,
}
impl<'de> DeserializeStrict<'de> for Policy {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "audience")]
            #[serde(default)]
            audience: Strict<Option<String>>,
            #[serde(rename = "conditions")]
            conditions: Strict<Vec<PolicyCondition>>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "issuer")]
            issuer: Strict<String>,
            #[serde(rename = "name")]
            #[serde(default)]
            name: Strict<Option<String>>,
            #[serde(rename = "workloadId")]
            workload_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            audience: wire.audience.0,
            conditions: wire.conditions.0,
            id: wire.id.0,
            issuer: wire.issuer.0,
            name: wire.name.0,
            workload_id: wire.workload_id.0,
        })
    }
}

/// One JWT claim that an external identity must match.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PolicyCondition {
    /// Contract field key.
    #[serde(rename = "key")]
    pub key: String,
    /// Contract field value.
    #[serde(rename = "value")]
    pub value: String,
}
impl<'de> DeserializeStrict<'de> for PolicyCondition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "key")]
            key: Strict<String>,
            #[serde(rename = "value")]
            value: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            key: wire.key.0,
            value: wire.value.0,
        })
    }
}

/// One live page of Policy records, ordered by ID. Continuations expire after one hour and bind the
/// credential, operation, filters and page size.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PolicyPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<Policy>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for PolicyPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "items")]
            items: Strict<Vec<Policy>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            items: wire.items.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// The created trust policy.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PolicyResponse {
    /// Contract field policy.
    #[serde(rename = "policy")]
    pub policy: Policy,
}
impl<'de> DeserializeStrict<'de> for PolicyResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "policy")]
            policy: Strict<Policy>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            policy: wire.policy.0,
        })
    }
}

/// A machine identity scoped to one Project.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Workload {
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field name.
    #[serde(rename = "name")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
}
impl<'de> DeserializeStrict<'de> for Workload {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "name")]
            #[serde(default)]
            name: Strict<Option<String>>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            id: wire.id.0,
            name: wire.name.0,
            project_id: wire.project_id.0,
        })
    }
}

/// One live page of Workload records, ordered by ID. Continuations expire after one hour and bind
/// the credential, operation, filters and page size.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkloadPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<Workload>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for WorkloadPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "items")]
            items: Strict<Vec<Workload>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            items: wire.items.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// The created machine identity.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkloadResponse {
    /// Contract field workload.
    #[serde(rename = "workload")]
    pub workload: Workload,
}
impl<'de> DeserializeStrict<'de> for WorkloadResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "workload")]
            workload: Strict<Workload>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            workload: wire.workload.0,
        })
    }
}

/// Typed errors declared by this service contract.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WorkloadsError {
    /// Workloads:Conflict.
    Conflict { reason: String },
    /// Workloads:InvalidArgument.
    InvalidArgument { reason: String },
    /// Workloads:LimitReached.
    LimitReached { reason: String },
    /// Workloads:NotFound.
    NotFound { resource: String },
}
impl WorkloadsError {
    /// HTTP status for this declared error.
    pub fn status(&self) -> u16 {
        match self {
            Self::Conflict { .. } => 409,
            Self::InvalidArgument { .. } => 400,
            Self::LimitReached { .. } => 412,
            Self::NotFound { .. } => 404,
        }
    }
    /// Serialize only contract-declared error parameters.
    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
        match self {
            Self::Conflict { reason } => {
                let mut envelope = ErrorEnvelope::new("CONFLICT", "Workloads:Conflict", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::InvalidArgument { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Workloads:InvalidArgument", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::LimitReached { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("FAILED_PRECONDITION", "Workloads:LimitReached", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::NotFound { resource } => {
                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Workloads:NotFound", instance);
                envelope
                    .parameters
                    .insert("resource".into(), resource.to_string());
                envelope
            }
        }
    }
    /// Decode a declared error and its typed error parameters.
    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        if envelope.error_instance_id.len() != 36
            || Uuid::parse_str(&envelope.error_instance_id).is_err()
        {
            return None;
        }
        match envelope.error_name.as_str() {
            "Workloads:Conflict" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::Conflict { reason })
            }
            "Workloads:InvalidArgument" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::InvalidArgument { reason })
            }
            "Workloads:LimitReached" => {
                if envelope.error_code != "FAILED_PRECONDITION" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::LimitReached { reason })
            }
            "Workloads:NotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let resource = envelope.parameters.get("resource")?.clone();
                Some(Self::NotFound { resource })
            }
            _ => None,
        }
    }
}
impl Display for WorkloadsError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Conflict { reason } => {
                write!(formatter, "Workloads:Conflict (reason: {})", reason)
            }
            Self::InvalidArgument { reason } => {
                write!(formatter, "Workloads:InvalidArgument (reason: {})", reason)
            }
            Self::LimitReached { reason } => {
                write!(formatter, "Workloads:LimitReached (reason: {})", reason)
            }
            Self::NotFound { resource } => {
                write!(formatter, "Workloads:NotFound (resource: {})", resource)
            }
        }
    }
}
impl StdError for WorkloadsError {}
impl ServiceError for WorkloadsError {
    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
        Self::envelope(self, instance)
    }
    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        Self::decode_envelope(envelope)
    }
}
#[automatically_derived]
impl Default for CreateWorkloadRequest {
    fn default() -> Self {
        Self { name: None }
    }
}
#[automatically_derived]
impl Default for PageRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
        }
    }
}