spiral-sdk 0.1.12

// 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, Serializer};
use serde_json::Value;
use spiral_contract::error::{ErrorEnvelope, ServiceError};
use spiral_contract::safelong::{SafeLong, SafeUnsignedLong};
use spiral_contract::strict::{DeserializeStrict, Strict};
use uuid::Uuid;

/// AwsSession contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AwsSession {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    /// Contract field expiresAtMicros.
    #[serde(rename = "expiresAtMicros")]
    pub expires_at_micros: SafeLong,
    /// Contract field region.
    #[serde(rename = "region")]
    pub region: String,
    /// Contract field secretAccessKey.
    #[serde(rename = "secretAccessKey")]
    pub secret_access_key: SecretToken,
    /// Contract field sessionToken.
    #[serde(rename = "sessionToken")]
    pub session_token: SecretToken,
}
impl<'de> DeserializeStrict<'de> for AwsSession {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "accessKeyId")]
            access_key_id: Strict<String>,
            #[serde(rename = "endpoint")]
            #[serde(default)]
            endpoint: Strict<Option<String>>,
            #[serde(rename = "expiresAtMicros")]
            expires_at_micros: Strict<SafeLong>,
            #[serde(rename = "region")]
            region: Strict<String>,
            #[serde(rename = "secretAccessKey")]
            secret_access_key: Strict<SecretToken>,
            #[serde(rename = "sessionToken")]
            session_token: Strict<SecretToken>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            endpoint: wire.endpoint.0,
            expires_at_micros: wire.expires_at_micros.0,
            region: wire.region.0,
            secret_access_key: wire.secret_access_key.0,
            session_token: wire.session_token.0,
        })
    }
}

/// CreateLocationRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateLocationRequest {
    /// Contract field backing.
    #[serde(rename = "backing")]
    pub backing: LocationBacking,
    /// Contract field inventory.
    #[serde(rename = "inventory")]
    pub inventory: LocationInventory,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
}
impl<'de> DeserializeStrict<'de> for CreateLocationRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "backing")]
            backing: Strict<LocationBacking>,
            #[serde(rename = "inventory")]
            inventory: Strict<LocationInventory>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            backing: wire.backing.0,
            inventory: wire.inventory.0,
            project_id: wire.project_id.0,
        })
    }
}

/// CreateLocationResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateLocationResponse {
    /// Contract field locationId.
    #[serde(rename = "locationId")]
    pub location_id: Uuid,
    /// Contract field version.
    #[serde(rename = "version")]
    pub version: LocationVersion,
}
impl<'de> DeserializeStrict<'de> for CreateLocationResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "locationId")]
            location_id: Strict<Uuid>,
            #[serde(rename = "version")]
            version: Strict<LocationVersion>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            location_id: wire.location_id.0,
            version: wire.version.0,
        })
    }
}

/// CreateVersionRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateVersionRequest {
    /// Contract field baseVersionId.
    #[serde(rename = "baseVersionId")]
    pub base_version_id: Uuid,
    /// Contract field change.
    #[serde(rename = "change")]
    pub change: VersionChange,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for CreateVersionRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "baseVersionId")]
            base_version_id: Strict<Uuid>,
            #[serde(rename = "change")]
            change: Strict<VersionChange>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            base_version_id: wire.base_version_id.0,
            change: wire.change.0,
            version_id: wire.version_id.0,
        })
    }
}

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

/// GcsAccessToken contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct GcsAccessToken {
    /// Contract field accessToken.
    #[serde(rename = "accessToken")]
    pub access_token: SecretToken,
    /// Contract field expiresAtMicros.
    #[serde(rename = "expiresAtMicros")]
    pub expires_at_micros: SafeLong,
}
impl<'de> DeserializeStrict<'de> for GcsAccessToken {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "accessToken")]
            access_token: Strict<SecretToken>,
            #[serde(rename = "expiresAtMicros")]
            expires_at_micros: Strict<SafeLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_token: wire.access_token.0,
            expires_at_micros: wire.expires_at_micros.0,
        })
    }
}

/// HuggingFaceToken contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct HuggingFaceToken {
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    /// Contract field expiresAtMicros.
    #[serde(rename = "expiresAtMicros")]
    pub expires_at_micros: SafeLong,
    /// Contract field token.
    #[serde(rename = "token")]
    pub token: SecretToken,
}
impl<'de> DeserializeStrict<'de> for HuggingFaceToken {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "endpoint")]
            endpoint: Strict<String>,
            #[serde(rename = "expiresAtMicros")]
            expires_at_micros: Strict<SafeLong>,
            #[serde(rename = "token")]
            token: Strict<SecretToken>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            endpoint: wire.endpoint.0,
            expires_at_micros: wire.expires_at_micros.0,
            token: wire.token.0,
        })
    }
}

/// LocationBacking contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LocationBacking {
    /// Contract field connectionId.
    #[serde(rename = "connectionId")]
    pub connection_id: Uuid,
    /// Contract field uri.
    #[serde(rename = "uri")]
    pub uri: String,
}
impl<'de> DeserializeStrict<'de> for LocationBacking {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "connectionId")]
            connection_id: Strict<Uuid>,
            #[serde(rename = "uri")]
            uri: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            connection_id: wire.connection_id.0,
            uri: wire.uri.0,
        })
    }
}

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

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

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

/// LocationVersion contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LocationVersion {
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field definition.
    #[serde(rename = "definition")]
    pub definition: LocationDefinition,
    /// Contract field locationId.
    #[serde(rename = "locationId")]
    pub location_id: Uuid,
    /// Contract field parentVersionId.
    #[serde(rename = "parentVersionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_version_id: Option<Uuid>,
    /// Contract field refresh.
    #[serde(rename = "refresh")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub refresh: Option<LocationRefresh>,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for LocationVersion {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "definition")]
            definition: Strict<LocationDefinition>,
            #[serde(rename = "locationId")]
            location_id: Strict<Uuid>,
            #[serde(rename = "parentVersionId")]
            #[serde(default)]
            parent_version_id: Strict<Option<Uuid>>,
            #[serde(rename = "refresh")]
            #[serde(default)]
            refresh: Strict<Option<LocationRefresh>>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            created_at_micros: wire.created_at_micros.0,
            definition: wire.definition.0,
            location_id: wire.location_id.0,
            parent_version_id: wire.parent_version_id.0,
            refresh: wire.refresh.0,
            version_id: wire.version_id.0,
        })
    }
}

/// A secret credential value.
#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct SecretToken(pub String);
impl std::fmt::Debug for SecretToken {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter.write_str("SecretToken(<redacted>)")
    }
}
impl<'de> DeserializeStrict<'de> for SecretToken {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

/// SignedAccess contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SignedAccess {
    /// Contract field directRead.
    #[serde(rename = "directRead")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub direct_read: Option<DirectRead>,
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    /// Contract field token.
    #[serde(rename = "token")]
    pub token: SecretToken,
}
impl<'de> DeserializeStrict<'de> for SignedAccess {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "directRead")]
            #[serde(default)]
            direct_read: Strict<Option<DirectRead>>,
            #[serde(rename = "endpoint")]
            endpoint: Strict<String>,
            #[serde(rename = "token")]
            token: Strict<SecretToken>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            direct_read: wire.direct_read.0,
            endpoint: wire.endpoint.0,
            token: wire.token.0,
        })
    }
}

/// StorageAccess contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum StorageAccess {
    /// A known union arm.
    Signed(SignedAccess),
    /// A known union arm.
    Vended(VendedAccess),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for StorageAccess {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Signed(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("signed".into()));
                object.insert(
                    "signed".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Vended(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("vended".into()));
                object.insert(
                    "vended".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 StorageAccess {
    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 {
            "signed" => Ok(Self::Signed(
                serde_json::from_value(
                    value
                        .get("signed")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "vended" => Ok(Self::Vended(
                serde_json::from_value(
                    value
                        .get("vended")
                        .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 StorageAccess {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "signed")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "signed")]
            value: Strict<SignedAccess>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "vended")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "vended")]
            value: Strict<VendedAccess>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Signed(Box<__Arm0>),
            Vended(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Signed(arm) => Self::Signed(arm.value.0),
            __Known::Vended(arm) => Self::Vended(arm.value.0),
        })
    }
}

/// StorageBinding contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct StorageBinding {
    /// Contract field access.
    #[serde(rename = "access")]
    pub access: StorageAccess,
    /// Contract field expiresAt.
    #[serde(rename = "expiresAt")]
    pub expires_at: SafeUnsignedLong,
    /// Contract field mode.
    #[serde(rename = "mode")]
    pub mode: StorageMode,
    /// Contract field rootUri.
    #[serde(rename = "rootUri")]
    pub root_uri: String,
}
impl<'de> DeserializeStrict<'de> for StorageBinding {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "access")]
            access: Strict<StorageAccess>,
            #[serde(rename = "expiresAt")]
            expires_at: Strict<SafeUnsignedLong>,
            #[serde(rename = "mode")]
            mode: Strict<StorageMode>,
            #[serde(rename = "rootUri")]
            root_uri: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access: wire.access.0,
            expires_at: wire.expires_at.0,
            mode: wire.mode.0,
            root_uri: wire.root_uri.0,
        })
    }
}

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

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

/// A short-lived provider credential. Renew it before it expires.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum VendedCredential {
    /// A known union arm.
    AwsSession(AwsSession),
    /// A known union arm.
    GcsAccessToken(GcsAccessToken),
    /// A known union arm.
    HuggingFaceToken(HuggingFaceToken),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for VendedCredential {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::AwsSession(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("awsSession".into()));
                object.insert(
                    "awsSession".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::GcsAccessToken(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("gcsAccessToken".into()));
                object.insert(
                    "gcsAccessToken".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::HuggingFaceToken(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("huggingFaceToken".into()));
                object.insert(
                    "huggingFaceToken".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 VendedCredential {
    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 {
            "awsSession" => Ok(Self::AwsSession(
                serde_json::from_value(
                    value
                        .get("awsSession")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "gcsAccessToken" => Ok(Self::GcsAccessToken(
                serde_json::from_value(
                    value
                        .get("gcsAccessToken")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "huggingFaceToken" => Ok(Self::HuggingFaceToken(
                serde_json::from_value(
                    value
                        .get("huggingFaceToken")
                        .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 VendedCredential {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "awsSession")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "awsSession")]
            value: Strict<AwsSession>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "gcsAccessToken")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "gcsAccessToken")]
            value: Strict<GcsAccessToken>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "huggingFaceToken")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "huggingFaceToken")]
            value: Strict<HuggingFaceToken>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            AwsSession(Box<__Arm0>),
            GcsAccessToken(Box<__Arm1>),
            HuggingFaceToken(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AwsSession(arm) => Self::AwsSession(arm.value.0),
            __Known::GcsAccessToken(arm) => Self::GcsAccessToken(arm.value.0),
            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
        })
    }
}

/// VersionChange contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum VersionChange {
    /// A known union arm.
    Refresh(LocationRefresh),
    /// A known union arm.
    Revise(LocationBacking),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for VersionChange {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Refresh(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("refresh".into()));
                object.insert(
                    "refresh".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Revise(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("revise".into()));
                object.insert(
                    "revise".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 VersionChange {
    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 {
            "refresh" => Ok(Self::Refresh(
                serde_json::from_value(
                    value
                        .get("refresh")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "revise" => Ok(Self::Revise(
                serde_json::from_value(
                    value
                        .get("revise")
                        .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 VersionChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "refresh")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "refresh")]
            value: Strict<LocationRefresh>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "revise")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "revise")]
            value: Strict<LocationBacking>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Refresh(Box<__Arm0>),
            Revise(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Refresh(arm) => Self::Refresh(arm.value.0),
            __Known::Revise(arm) => Self::Revise(arm.value.0),
        })
    }
}

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

/// Typed errors declared by this service contract.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum LocationsError {
    /// Locations:Conflict.
    Conflict { reason: String },
    /// Locations:InvalidArgument.
    InvalidArgument { reason: String },
    /// Locations:NotFound.
    NotFound { resource: String },
}
impl LocationsError {
    /// HTTP status for this declared error.
    pub fn status(&self) -> u16 {
        match self {
            Self::Conflict { .. } => 409,
            Self::InvalidArgument { .. } => 400,
            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", "Locations:Conflict", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::InvalidArgument { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Locations:InvalidArgument", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::NotFound { resource } => {
                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Locations: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() {
            "Locations:Conflict" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::Conflict { reason })
            }
            "Locations:InvalidArgument" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::InvalidArgument { reason })
            }
            "Locations:NotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let resource = envelope.parameters.get("resource")?.clone();
                Some(Self::NotFound { resource })
            }
            _ => None,
        }
    }
}
impl Display for LocationsError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Conflict { reason } => {
                write!(formatter, "Locations:Conflict (reason: {})", reason)
            }
            Self::InvalidArgument { reason } => {
                write!(formatter, "Locations:InvalidArgument (reason: {})", reason)
            }
            Self::NotFound { resource } => {
                write!(formatter, "Locations:NotFound (resource: {})", resource)
            }
        }
    }
}
impl StdError for LocationsError {}
impl ServiceError for LocationsError {
    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
        Self::envelope(self, instance)
    }
    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        Self::decode_envelope(envelope)
    }
}