spiral-sdk 0.1.8

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

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

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

/// A role granted to a principal in one Project.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Grant {
    /// Contract field conditions.
    #[serde(rename = "conditions")]
    pub conditions: BTreeMap<String, String>,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field principal.
    #[serde(rename = "principal")]
    pub principal: String,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field role.
    #[serde(rename = "role")]
    pub role: Role,
}
impl<'de> DeserializeStrict<'de> for Grant {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "conditions")]
            conditions: Strict<BTreeMap<String, String>>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "principal")]
            principal: Strict<String>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "role")]
            role: Strict<Role>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            conditions: wire.conditions.0,
            id: wire.id.0,
            principal: wire.principal.0,
            project_id: wire.project_id.0,
            role: wire.role.0,
        })
    }
}

/// One live page of Grant 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 GrantPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<Grant>,
    /// 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 GrantPage {
    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<Grant>>,
            #[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 Project role grant.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct GrantResponse {
    /// Contract field grant.
    #[serde(rename = "grant")]
    pub grant: Grant,
}
impl<'de> DeserializeStrict<'de> for GrantResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "grant")]
            grant: Strict<Grant>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            grant: wire.grant.0,
        })
    }
}

/// A Project role and the principal receiving it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct GrantRoleRequest {
    /// Contract field principal.
    #[serde(rename = "principal")]
    pub principal: Principal,
    /// Contract field role.
    #[serde(rename = "role")]
    pub role: Role,
}
impl<'de> DeserializeStrict<'de> for GrantRoleRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "principal")]
            principal: Strict<Principal>,
            #[serde(rename = "role")]
            role: Strict<Role>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            principal: wire.principal.0,
            role: wire.role.0,
        })
    }
}

/// One batch of resource permission edges reviewed together.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Installation {
    /// Contract field createdAt.
    #[serde(rename = "createdAt")]
    pub created_at: String,
    /// Contract field createdBy.
    #[serde(rename = "createdBy")]
    pub created_by: String,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field resourceMounts.
    #[serde(rename = "resourceMounts")]
    pub resource_mounts: Vec<ResourceMount>,
    /// Contract field source.
    #[serde(rename = "source")]
    pub source: String,
}
impl<'de> DeserializeStrict<'de> for Installation {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "createdAt")]
            created_at: Strict<String>,
            #[serde(rename = "createdBy")]
            created_by: Strict<String>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "resourceMounts")]
            resource_mounts: Strict<Vec<ResourceMount>>,
            #[serde(rename = "source")]
            source: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            created_at: wire.created_at.0,
            created_by: wire.created_by.0,
            id: wire.id.0,
            resource_mounts: wire.resource_mounts.0,
            source: wire.source.0,
        })
    }
}

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

/// Continuation and optional exact principal-address filter. Page size defaults to 100 and must be
/// 1..=1000. Continuations expire after one hour and bind the credential, filters and page size.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListGrantsRequest {
    /// 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>,
    /// Contract field principal.
    #[serde(rename = "principal")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub principal: Option<String>,
}
impl<'de> DeserializeStrict<'de> for ListGrantsRequest {
    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>>,
            #[serde(rename = "principal")]
            #[serde(default)]
            principal: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
            principal: wire.principal.0,
        })
    }
}

/// Whether to approve or reject a requested resource permission edge.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum MountDecision {
    /// A known contract value.
    Approve,
    /// A known contract value.
    Reject,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for MountDecision {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Approve => "approve",
            Self::Reject => "reject",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for MountDecision {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "approve" => Self::Approve,
            "reject" => Self::Reject,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for MountDecision {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "approve")]
            Approve,
            #[serde(rename = "reject")]
            Reject,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Approve => Self::Approve,
            __Known::Reject => Self::Reject,
        })
    }
}

/// Lifecycle status of a resource permission edge.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum MountStatus {
    /// A known contract value.
    Requested,
    /// A known contract value.
    Approved,
    /// A known contract value.
    Rejected,
    /// A known contract value.
    Revoked,
    /// A known contract value.
    Detached,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for MountStatus {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Requested => "requested",
            Self::Approved => "approved",
            Self::Rejected => "rejected",
            Self::Revoked => "revoked",
            Self::Detached => "detached",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for MountStatus {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "requested" => Self::Requested,
            "approved" => Self::Approved,
            "rejected" => Self::Rejected,
            "revoked" => Self::Revoked,
            "detached" => Self::Detached,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for MountStatus {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "requested")]
            Requested,
            #[serde(rename = "approved")]
            Approved,
            #[serde(rename = "rejected")]
            Rejected,
            #[serde(rename = "revoked")]
            Revoked,
            #[serde(rename = "detached")]
            Detached,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Requested => Self::Requested,
            __Known::Approved => Self::Approved,
            __Known::Rejected => Self::Rejected,
            __Known::Revoked => Self::Revoked,
            __Known::Detached => Self::Detached,
        })
    }
}

/// Match an Organization membership role.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrganizationRolePrincipal {
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
    /// Contract field role.
    #[serde(rename = "role")]
    pub role: String,
}
impl<'de> DeserializeStrict<'de> for OrganizationRolePrincipal {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
            #[serde(rename = "role")]
            role: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            organization_id: wire.organization_id.0,
            role: wire.role.0,
        })
    }
}

/// Match a user acting in an Organization.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrganizationUserPrincipal {
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
    /// Contract field userId.
    #[serde(rename = "userId")]
    pub user_id: String,
}
impl<'de> DeserializeStrict<'de> for OrganizationUserPrincipal {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
            #[serde(rename = "userId")]
            user_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            organization_id: wire.organization_id.0,
            user_id: wire.user_id.0,
        })
    }
}

/// The identity or membership role that receives a Project role.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Principal {
    /// A known union arm.
    OrganizationRole(OrganizationRolePrincipal),
    /// A known union arm.
    OrganizationUser(OrganizationUserPrincipal),
    /// A known union arm.
    Workload(WorkloadPrincipal),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for Principal {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::OrganizationRole(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("organizationRole".into()));
                object.insert(
                    "organizationRole".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::OrganizationUser(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("organizationUser".into()));
                object.insert(
                    "organizationUser".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Workload(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("workload".into()));
                object.insert(
                    "workload".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for Principal {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "organizationRole" => Ok(Self::OrganizationRole(
                serde_json::from_value(
                    value
                        .get("organizationRole")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "organizationUser" => Ok(Self::OrganizationUser(
                serde_json::from_value(
                    value
                        .get("organizationUser")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "workload" => Ok(Self::Workload(
                serde_json::from_value(
                    value
                        .get("workload")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for Principal {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "organizationRole")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "organizationRole")]
            value: Strict<OrganizationRolePrincipal>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "organizationUser")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "organizationUser")]
            value: Strict<OrganizationUserPrincipal>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "workload")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "workload")]
            value: Strict<WorkloadPrincipal>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            OrganizationRole(Box<__Arm0>),
            OrganizationUser(Box<__Arm1>),
            Workload(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::OrganizationRole(arm) => Self::OrganizationRole(arm.value.0),
            __Known::OrganizationUser(arm) => Self::OrganizationUser(arm.value.0),
            __Known::Workload(arm) => Self::Workload(arm.value.0),
        })
    }
}

/// A permission edge between two resources, with its decision and audit metadata.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceMount {
    /// Contract field createdAt.
    #[serde(rename = "createdAt")]
    pub created_at: String,
    /// Contract field createdBy.
    #[serde(rename = "createdBy")]
    pub created_by: String,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field installationId.
    #[serde(rename = "installationId")]
    pub installation_id: String,
    /// Contract field permission.
    #[serde(rename = "permission")]
    pub permission: String,
    /// Contract field source.
    #[serde(rename = "source")]
    pub source: String,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: MountStatus,
    /// Contract field statusChangedAt.
    #[serde(rename = "statusChangedAt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status_changed_at: Option<String>,
    /// Contract field statusChangedBy.
    #[serde(rename = "statusChangedBy")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status_changed_by: Option<String>,
    /// Contract field target.
    #[serde(rename = "target")]
    pub target: String,
}
impl<'de> DeserializeStrict<'de> for ResourceMount {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "createdAt")]
            created_at: Strict<String>,
            #[serde(rename = "createdBy")]
            created_by: Strict<String>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "installationId")]
            installation_id: Strict<String>,
            #[serde(rename = "permission")]
            permission: Strict<String>,
            #[serde(rename = "source")]
            source: Strict<String>,
            #[serde(rename = "status")]
            status: Strict<MountStatus>,
            #[serde(rename = "statusChangedAt")]
            #[serde(default)]
            status_changed_at: Strict<Option<String>>,
            #[serde(rename = "statusChangedBy")]
            #[serde(default)]
            status_changed_by: Strict<Option<String>>,
            #[serde(rename = "target")]
            target: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            created_at: wire.created_at.0,
            created_by: wire.created_by.0,
            id: wire.id.0,
            installation_id: wire.installation_id.0,
            permission: wire.permission.0,
            source: wire.source.0,
            status: wire.status.0,
            status_changed_at: wire.status_changed_at.0,
            status_changed_by: wire.status_changed_by.0,
            target: wire.target.0,
        })
    }
}

/// Decisions keyed by resource mount ID. Omitted edges remain requested.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReviewRequest {
    /// Contract field decisions.
    #[serde(rename = "decisions")]
    pub decisions: BTreeMap<String, MountDecision>,
}
impl<'de> DeserializeStrict<'de> for ReviewRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "decisions")]
            decisions: Strict<BTreeMap<String, MountDecision>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            decisions: wire.decisions.0,
        })
    }
}

/// The resource permission edges transitioned by this decision.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReviewResponse {
    /// Contract field resourceMounts.
    #[serde(rename = "resourceMounts")]
    pub resource_mounts: Vec<ResourceMount>,
}
impl<'de> DeserializeStrict<'de> for ReviewResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "resourceMounts")]
            resource_mounts: Strict<Vec<ResourceMount>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            resource_mounts: wire.resource_mounts.0,
        })
    }
}

/// Project authorization role.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Role {
    /// A known contract value.
    Admin,
    /// A known contract value.
    Editor,
    /// A known contract value.
    Viewer,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for Role {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Admin => "admin",
            Self::Editor => "editor",
            Self::Viewer => "viewer",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for Role {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "admin" => Self::Admin,
            "editor" => Self::Editor,
            "viewer" => Self::Viewer,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for Role {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "admin")]
            Admin,
            #[serde(rename = "editor")]
            Editor,
            #[serde(rename = "viewer")]
            Viewer,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Admin => Self::Admin,
            __Known::Editor => Self::Editor,
            __Known::Viewer => Self::Viewer,
        })
    }
}

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

/// Typed errors declared by this service contract.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AuthorizationError {
    /// Authorization:Conflict.
    Conflict { reason: String },
    /// Authorization:InvalidArgument.
    InvalidArgument { reason: String },
    /// Authorization:LimitReached.
    LimitReached { reason: String },
    /// Authorization:NotFound.
    NotFound { resource: String },
}
impl AuthorizationError {
    /// 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", "Authorization:Conflict", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::InvalidArgument { reason } => {
                let mut envelope = ErrorEnvelope::new(
                    "INVALID_ARGUMENT",
                    "Authorization:InvalidArgument",
                    instance,
                );
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::LimitReached { reason } => {
                let mut envelope = ErrorEnvelope::new(
                    "FAILED_PRECONDITION",
                    "Authorization:LimitReached",
                    instance,
                );
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::NotFound { resource } => {
                let mut envelope =
                    ErrorEnvelope::new("NOT_FOUND", "Authorization: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() {
            "Authorization:Conflict" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::Conflict { reason })
            }
            "Authorization:InvalidArgument" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::InvalidArgument { reason })
            }
            "Authorization:LimitReached" => {
                if envelope.error_code != "FAILED_PRECONDITION" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::LimitReached { reason })
            }
            "Authorization:NotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let resource = envelope.parameters.get("resource")?.clone();
                Some(Self::NotFound { resource })
            }
            _ => None,
        }
    }
}
impl Display for AuthorizationError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Conflict { reason } => {
                write!(formatter, "Authorization:Conflict (reason: {})", reason)
            }
            Self::InvalidArgument { reason } => write!(
                formatter,
                "Authorization:InvalidArgument (reason: {})",
                reason
            ),
            Self::LimitReached { reason } => {
                write!(formatter, "Authorization:LimitReached (reason: {})", reason)
            }
            Self::NotFound { resource } => {
                write!(formatter, "Authorization:NotFound (resource: {})", resource)
            }
        }
    }
}
impl StdError for AuthorizationError {}
impl ServiceError for AuthorizationError {
    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 ListGrantsRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
            principal: None,
        }
    }
}