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;
use spiral_contract::strict::{DeserializeStrict, Strict};
use uuid::Uuid;

/// AwsAccessKey contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AwsAccessKey {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field region.
    #[serde(rename = "region")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    /// Contract field secretAccessKey.
    #[serde(rename = "secretAccessKey")]
    pub secret_access_key: SecretToken,
}
impl<'de> DeserializeStrict<'de> for AwsAccessKey {
    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 = "region")]
            #[serde(default)]
            region: Strict<Option<String>>,
            #[serde(rename = "secretAccessKey")]
            secret_access_key: Strict<SecretToken>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            region: wire.region.0,
            secret_access_key: wire.secret_access_key.0,
        })
    }
}

/// AwsAccessKeyConfig contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AwsAccessKeyConfig {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field region.
    #[serde(rename = "region")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
}
impl<'de> DeserializeStrict<'de> for AwsAccessKeyConfig {
    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 = "region")]
            #[serde(default)]
            region: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            region: wire.region.0,
        })
    }
}

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

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

/// 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,
        })
    }
}

/// CephAccessKey contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CephAccessKey {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    /// Contract field region.
    #[serde(rename = "region")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    /// Contract field roleArn.
    #[serde(rename = "roleArn")]
    pub role_arn: String,
    /// Contract field secretAccessKey.
    #[serde(rename = "secretAccessKey")]
    pub secret_access_key: SecretToken,
}
impl<'de> DeserializeStrict<'de> for CephAccessKey {
    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")]
            endpoint: Strict<String>,
            #[serde(rename = "region")]
            #[serde(default)]
            region: Strict<Option<String>>,
            #[serde(rename = "roleArn")]
            role_arn: Strict<String>,
            #[serde(rename = "secretAccessKey")]
            secret_access_key: Strict<SecretToken>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            endpoint: wire.endpoint.0,
            region: wire.region.0,
            role_arn: wire.role_arn.0,
            secret_access_key: wire.secret_access_key.0,
        })
    }
}

/// CephAccessKeyConfig contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CephAccessKeyConfig {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    /// Contract field region.
    #[serde(rename = "region")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    /// Contract field roleArn.
    #[serde(rename = "roleArn")]
    pub role_arn: String,
}
impl<'de> DeserializeStrict<'de> for CephAccessKeyConfig {
    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")]
            endpoint: Strict<String>,
            #[serde(rename = "region")]
            #[serde(default)]
            region: Strict<Option<String>>,
            #[serde(rename = "roleArn")]
            role_arn: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            endpoint: wire.endpoint.0,
            region: wire.region.0,
            role_arn: wire.role_arn.0,
        })
    }
}

/// CephOidc contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CephOidc {
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    /// Contract field region.
    #[serde(rename = "region")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    /// Contract field roleArn.
    #[serde(rename = "roleArn")]
    pub role_arn: String,
}
impl<'de> DeserializeStrict<'de> for CephOidc {
    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 = "region")]
            #[serde(default)]
            region: Strict<Option<String>>,
            #[serde(rename = "roleArn")]
            role_arn: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            endpoint: wire.endpoint.0,
            region: wire.region.0,
            role_arn: wire.role_arn.0,
        })
    }
}

/// CephOidcConfig contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CephOidcConfig {
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    /// Contract field region.
    #[serde(rename = "region")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    /// Contract field roleArn.
    #[serde(rename = "roleArn")]
    pub role_arn: String,
}
impl<'de> DeserializeStrict<'de> for CephOidcConfig {
    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 = "region")]
            #[serde(default)]
            region: Strict<Option<String>>,
            #[serde(rename = "roleArn")]
            role_arn: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            endpoint: wire.endpoint.0,
            region: wire.region.0,
            role_arn: wire.role_arn.0,
        })
    }
}

/// Connection contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Connection {
    /// Contract field allowedAccess.
    #[serde(rename = "allowedAccess")]
    pub allowed_access: ConnectionAccess,
    /// Contract field connectionId.
    #[serde(rename = "connectionId")]
    pub connection_id: Uuid,
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field createdBy.
    #[serde(rename = "createdBy")]
    pub created_by: String,
    /// Contract field credential.
    #[serde(rename = "credential")]
    pub credential: CredentialConfig,
    /// Contract field credentialUpdatedAtMicros.
    #[serde(rename = "credentialUpdatedAtMicros")]
    pub credential_updated_at_micros: SafeLong,
    /// Contract field description.
    #[serde(rename = "description")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Contract field dropped.
    #[serde(rename = "dropped")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dropped: Option<DropRecord>,
    /// Contract field identity.
    #[serde(rename = "identity")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub identity: Option<ConnectionIdentity>,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field uri.
    #[serde(rename = "uri")]
    pub uri: String,
}
impl<'de> DeserializeStrict<'de> for Connection {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "allowedAccess")]
            allowed_access: Strict<ConnectionAccess>,
            #[serde(rename = "connectionId")]
            connection_id: Strict<Uuid>,
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "createdBy")]
            created_by: Strict<String>,
            #[serde(rename = "credential")]
            credential: Strict<CredentialConfig>,
            #[serde(rename = "credentialUpdatedAtMicros")]
            credential_updated_at_micros: Strict<SafeLong>,
            #[serde(rename = "description")]
            #[serde(default)]
            description: Strict<Option<String>>,
            #[serde(rename = "dropped")]
            #[serde(default)]
            dropped: Strict<Option<DropRecord>>,
            #[serde(rename = "identity")]
            #[serde(default)]
            identity: Strict<Option<ConnectionIdentity>>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "uri")]
            uri: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            allowed_access: wire.allowed_access.0,
            connection_id: wire.connection_id.0,
            created_at_micros: wire.created_at_micros.0,
            created_by: wire.created_by.0,
            credential: wire.credential.0,
            credential_updated_at_micros: wire.credential_updated_at_micros.0,
            description: wire.description.0,
            dropped: wire.dropped.0,
            identity: wire.identity.0,
            project_id: wire.project_id.0,
            uri: wire.uri.0,
        })
    }
}

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

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

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

/// CreateConnectionRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateConnectionRequest {
    /// Contract field credential.
    #[serde(rename = "credential")]
    pub credential: Credential,
    /// Contract field description.
    #[serde(rename = "description")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field uri.
    #[serde(rename = "uri")]
    pub uri: String,
}
impl<'de> DeserializeStrict<'de> for CreateConnectionRequest {
    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<Credential>,
            #[serde(rename = "description")]
            #[serde(default)]
            description: Strict<Option<String>>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "uri")]
            uri: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            credential: wire.credential.0,
            description: wire.description.0,
            project_id: wire.project_id.0,
            uri: wire.uri.0,
        })
    }
}

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

/// A complete replacement credential, including every required secret. OIDC credentials contain no
/// stored secret.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Credential {
    /// A known union arm.
    AwsAccessKey(AwsAccessKey),
    /// A known union arm.
    AwsOidc(AwsOidc),
    /// A known union arm.
    CephAccessKey(CephAccessKey),
    /// A known union arm.
    CephOidc(CephOidc),
    /// A known union arm.
    GcsOidc(GcsOidc),
    /// A known union arm.
    GcsServiceAccountKey(GcsServiceAccountKey),
    /// A known union arm.
    HuggingFaceToken(HuggingFaceCredential),
    /// A known union arm.
    MinioAccessKey(S3AccessKey),
    /// A known union arm.
    R2AccessKey(R2AccessKey),
    /// A known union arm.
    RustfsAccessKey(S3AccessKey),
    /// A known union arm.
    S3LikeAccessKey(S3AccessKey),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for Credential {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::AwsAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("awsAccessKey".into()));
                object.insert(
                    "awsAccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::AwsOidc(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("awsOidc".into()));
                object.insert(
                    "awsOidc".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::CephAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("cephAccessKey".into()));
                object.insert(
                    "cephAccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::CephOidc(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("cephOidc".into()));
                object.insert(
                    "cephOidc".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::GcsOidc(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("gcsOidc".into()));
                object.insert(
                    "gcsOidc".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::GcsServiceAccountKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("gcsServiceAccountKey".into()));
                object.insert(
                    "gcsServiceAccountKey".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::MinioAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("minioAccessKey".into()));
                object.insert(
                    "minioAccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::R2AccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("r2AccessKey".into()));
                object.insert(
                    "r2AccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::RustfsAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("rustfsAccessKey".into()));
                object.insert(
                    "rustfsAccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::S3LikeAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("s3LikeAccessKey".into()));
                object.insert(
                    "s3LikeAccessKey".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 Credential {
    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 {
            "awsAccessKey" => Ok(Self::AwsAccessKey(
                serde_json::from_value(
                    value
                        .get("awsAccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "awsOidc" => Ok(Self::AwsOidc(
                serde_json::from_value(
                    value
                        .get("awsOidc")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "cephAccessKey" => Ok(Self::CephAccessKey(
                serde_json::from_value(
                    value
                        .get("cephAccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "cephOidc" => Ok(Self::CephOidc(
                serde_json::from_value(
                    value
                        .get("cephOidc")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "gcsOidc" => Ok(Self::GcsOidc(
                serde_json::from_value(
                    value
                        .get("gcsOidc")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "gcsServiceAccountKey" => Ok(Self::GcsServiceAccountKey(
                serde_json::from_value(
                    value
                        .get("gcsServiceAccountKey")
                        .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)?,
            )),
            "minioAccessKey" => Ok(Self::MinioAccessKey(
                serde_json::from_value(
                    value
                        .get("minioAccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "r2AccessKey" => Ok(Self::R2AccessKey(
                serde_json::from_value(
                    value
                        .get("r2AccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "rustfsAccessKey" => Ok(Self::RustfsAccessKey(
                serde_json::from_value(
                    value
                        .get("rustfsAccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "s3LikeAccessKey" => Ok(Self::S3LikeAccessKey(
                serde_json::from_value(
                    value
                        .get("s3LikeAccessKey")
                        .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 Credential {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "awsAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "awsAccessKey")]
            value: Strict<AwsAccessKey>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "awsOidc")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "awsOidc")]
            value: Strict<AwsOidc>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "cephAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "cephAccessKey")]
            value: Strict<CephAccessKey>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "cephOidc")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "cephOidc")]
            value: Strict<CephOidc>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "gcsOidc")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "gcsOidc")]
            value: Strict<GcsOidc>,
        }
        #[derive(Deserialize)]
        enum __Tag5 {
            #[serde(rename = "gcsServiceAccountKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm5 {
            #[serde(rename = "type")]
            _tag: __Tag5,
            #[serde(rename = "gcsServiceAccountKey")]
            value: Strict<GcsServiceAccountKey>,
        }
        #[derive(Deserialize)]
        enum __Tag6 {
            #[serde(rename = "huggingFaceToken")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm6 {
            #[serde(rename = "type")]
            _tag: __Tag6,
            #[serde(rename = "huggingFaceToken")]
            value: Strict<HuggingFaceCredential>,
        }
        #[derive(Deserialize)]
        enum __Tag7 {
            #[serde(rename = "minioAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm7 {
            #[serde(rename = "type")]
            _tag: __Tag7,
            #[serde(rename = "minioAccessKey")]
            value: Strict<S3AccessKey>,
        }
        #[derive(Deserialize)]
        enum __Tag8 {
            #[serde(rename = "r2AccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm8 {
            #[serde(rename = "type")]
            _tag: __Tag8,
            #[serde(rename = "r2AccessKey")]
            value: Strict<R2AccessKey>,
        }
        #[derive(Deserialize)]
        enum __Tag9 {
            #[serde(rename = "rustfsAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm9 {
            #[serde(rename = "type")]
            _tag: __Tag9,
            #[serde(rename = "rustfsAccessKey")]
            value: Strict<S3AccessKey>,
        }
        #[derive(Deserialize)]
        enum __Tag10 {
            #[serde(rename = "s3LikeAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm10 {
            #[serde(rename = "type")]
            _tag: __Tag10,
            #[serde(rename = "s3LikeAccessKey")]
            value: Strict<S3AccessKey>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            AwsAccessKey(Box<__Arm0>),
            AwsOidc(Box<__Arm1>),
            CephAccessKey(Box<__Arm2>),
            CephOidc(Box<__Arm3>),
            GcsOidc(Box<__Arm4>),
            GcsServiceAccountKey(Box<__Arm5>),
            HuggingFaceToken(Box<__Arm6>),
            MinioAccessKey(Box<__Arm7>),
            R2AccessKey(Box<__Arm8>),
            RustfsAccessKey(Box<__Arm9>),
            S3LikeAccessKey(Box<__Arm10>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AwsAccessKey(arm) => Self::AwsAccessKey(arm.value.0),
            __Known::AwsOidc(arm) => Self::AwsOidc(arm.value.0),
            __Known::CephAccessKey(arm) => Self::CephAccessKey(arm.value.0),
            __Known::CephOidc(arm) => Self::CephOidc(arm.value.0),
            __Known::GcsOidc(arm) => Self::GcsOidc(arm.value.0),
            __Known::GcsServiceAccountKey(arm) => Self::GcsServiceAccountKey(arm.value.0),
            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
            __Known::MinioAccessKey(arm) => Self::MinioAccessKey(arm.value.0),
            __Known::R2AccessKey(arm) => Self::R2AccessKey(arm.value.0),
            __Known::RustfsAccessKey(arm) => Self::RustfsAccessKey(arm.value.0),
            __Known::S3LikeAccessKey(arm) => Self::S3LikeAccessKey(arm.value.0),
        })
    }
}

/// The credential configuration returned by reads. It has no fields for stored secrets.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CredentialConfig {
    /// A known union arm.
    AwsAccessKey(AwsAccessKeyConfig),
    /// A known union arm.
    AwsOidc(AwsOidcConfig),
    /// A known union arm.
    CephAccessKey(CephAccessKeyConfig),
    /// A known union arm.
    CephOidc(CephOidcConfig),
    /// A known union arm.
    GcsOidc(GcsOidcConfig),
    /// A known union arm.
    GcsServiceAccountKey(GcsServiceAccountKeyConfig),
    /// A known union arm.
    HuggingFaceToken(HuggingFaceCredentialConfig),
    /// A known union arm.
    MinioAccessKey(S3AccessKeyConfig),
    /// A known union arm.
    R2AccessKey(R2AccessKeyConfig),
    /// A known union arm.
    RustfsAccessKey(S3AccessKeyConfig),
    /// A known union arm.
    S3LikeAccessKey(S3AccessKeyConfig),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for CredentialConfig {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::AwsAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("awsAccessKey".into()));
                object.insert(
                    "awsAccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::AwsOidc(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("awsOidc".into()));
                object.insert(
                    "awsOidc".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::CephAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("cephAccessKey".into()));
                object.insert(
                    "cephAccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::CephOidc(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("cephOidc".into()));
                object.insert(
                    "cephOidc".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::GcsOidc(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("gcsOidc".into()));
                object.insert(
                    "gcsOidc".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::GcsServiceAccountKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("gcsServiceAccountKey".into()));
                object.insert(
                    "gcsServiceAccountKey".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::MinioAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("minioAccessKey".into()));
                object.insert(
                    "minioAccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::R2AccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("r2AccessKey".into()));
                object.insert(
                    "r2AccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::RustfsAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("rustfsAccessKey".into()));
                object.insert(
                    "rustfsAccessKey".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::S3LikeAccessKey(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("s3LikeAccessKey".into()));
                object.insert(
                    "s3LikeAccessKey".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 CredentialConfig {
    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 {
            "awsAccessKey" => Ok(Self::AwsAccessKey(
                serde_json::from_value(
                    value
                        .get("awsAccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "awsOidc" => Ok(Self::AwsOidc(
                serde_json::from_value(
                    value
                        .get("awsOidc")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "cephAccessKey" => Ok(Self::CephAccessKey(
                serde_json::from_value(
                    value
                        .get("cephAccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "cephOidc" => Ok(Self::CephOidc(
                serde_json::from_value(
                    value
                        .get("cephOidc")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "gcsOidc" => Ok(Self::GcsOidc(
                serde_json::from_value(
                    value
                        .get("gcsOidc")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "gcsServiceAccountKey" => Ok(Self::GcsServiceAccountKey(
                serde_json::from_value(
                    value
                        .get("gcsServiceAccountKey")
                        .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)?,
            )),
            "minioAccessKey" => Ok(Self::MinioAccessKey(
                serde_json::from_value(
                    value
                        .get("minioAccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "r2AccessKey" => Ok(Self::R2AccessKey(
                serde_json::from_value(
                    value
                        .get("r2AccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "rustfsAccessKey" => Ok(Self::RustfsAccessKey(
                serde_json::from_value(
                    value
                        .get("rustfsAccessKey")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "s3LikeAccessKey" => Ok(Self::S3LikeAccessKey(
                serde_json::from_value(
                    value
                        .get("s3LikeAccessKey")
                        .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 CredentialConfig {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "awsAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "awsAccessKey")]
            value: Strict<AwsAccessKeyConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "awsOidc")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "awsOidc")]
            value: Strict<AwsOidcConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "cephAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "cephAccessKey")]
            value: Strict<CephAccessKeyConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "cephOidc")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "cephOidc")]
            value: Strict<CephOidcConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "gcsOidc")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "gcsOidc")]
            value: Strict<GcsOidcConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag5 {
            #[serde(rename = "gcsServiceAccountKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm5 {
            #[serde(rename = "type")]
            _tag: __Tag5,
            #[serde(rename = "gcsServiceAccountKey")]
            value: Strict<GcsServiceAccountKeyConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag6 {
            #[serde(rename = "huggingFaceToken")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm6 {
            #[serde(rename = "type")]
            _tag: __Tag6,
            #[serde(rename = "huggingFaceToken")]
            value: Strict<HuggingFaceCredentialConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag7 {
            #[serde(rename = "minioAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm7 {
            #[serde(rename = "type")]
            _tag: __Tag7,
            #[serde(rename = "minioAccessKey")]
            value: Strict<S3AccessKeyConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag8 {
            #[serde(rename = "r2AccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm8 {
            #[serde(rename = "type")]
            _tag: __Tag8,
            #[serde(rename = "r2AccessKey")]
            value: Strict<R2AccessKeyConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag9 {
            #[serde(rename = "rustfsAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm9 {
            #[serde(rename = "type")]
            _tag: __Tag9,
            #[serde(rename = "rustfsAccessKey")]
            value: Strict<S3AccessKeyConfig>,
        }
        #[derive(Deserialize)]
        enum __Tag10 {
            #[serde(rename = "s3LikeAccessKey")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm10 {
            #[serde(rename = "type")]
            _tag: __Tag10,
            #[serde(rename = "s3LikeAccessKey")]
            value: Strict<S3AccessKeyConfig>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            AwsAccessKey(Box<__Arm0>),
            AwsOidc(Box<__Arm1>),
            CephAccessKey(Box<__Arm2>),
            CephOidc(Box<__Arm3>),
            GcsOidc(Box<__Arm4>),
            GcsServiceAccountKey(Box<__Arm5>),
            HuggingFaceToken(Box<__Arm6>),
            MinioAccessKey(Box<__Arm7>),
            R2AccessKey(Box<__Arm8>),
            RustfsAccessKey(Box<__Arm9>),
            S3LikeAccessKey(Box<__Arm10>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AwsAccessKey(arm) => Self::AwsAccessKey(arm.value.0),
            __Known::AwsOidc(arm) => Self::AwsOidc(arm.value.0),
            __Known::CephAccessKey(arm) => Self::CephAccessKey(arm.value.0),
            __Known::CephOidc(arm) => Self::CephOidc(arm.value.0),
            __Known::GcsOidc(arm) => Self::GcsOidc(arm.value.0),
            __Known::GcsServiceAccountKey(arm) => Self::GcsServiceAccountKey(arm.value.0),
            __Known::HuggingFaceToken(arm) => Self::HuggingFaceToken(arm.value.0),
            __Known::MinioAccessKey(arm) => Self::MinioAccessKey(arm.value.0),
            __Known::R2AccessKey(arm) => Self::R2AccessKey(arm.value.0),
            __Known::RustfsAccessKey(arm) => Self::RustfsAccessKey(arm.value.0),
            __Known::S3LikeAccessKey(arm) => Self::S3LikeAccessKey(arm.value.0),
        })
    }
}

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

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

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

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

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

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

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

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

/// R2AccessKey contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct R2AccessKey {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field accountId.
    #[serde(rename = "accountId")]
    pub account_id: String,
    /// Contract field jurisdiction.
    #[serde(rename = "jurisdiction")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub jurisdiction: Option<R2Jurisdiction>,
    /// Contract field secretAccessKey.
    #[serde(rename = "secretAccessKey")]
    pub secret_access_key: SecretToken,
}
impl<'de> DeserializeStrict<'de> for R2AccessKey {
    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 = "accountId")]
            account_id: Strict<String>,
            #[serde(rename = "jurisdiction")]
            #[serde(default)]
            jurisdiction: Strict<Option<R2Jurisdiction>>,
            #[serde(rename = "secretAccessKey")]
            secret_access_key: Strict<SecretToken>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            account_id: wire.account_id.0,
            jurisdiction: wire.jurisdiction.0,
            secret_access_key: wire.secret_access_key.0,
        })
    }
}

/// R2AccessKeyConfig contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct R2AccessKeyConfig {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field accountId.
    #[serde(rename = "accountId")]
    pub account_id: String,
    /// Contract field jurisdiction.
    #[serde(rename = "jurisdiction")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub jurisdiction: Option<R2Jurisdiction>,
}
impl<'de> DeserializeStrict<'de> for R2AccessKeyConfig {
    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 = "accountId")]
            account_id: Strict<String>,
            #[serde(rename = "jurisdiction")]
            #[serde(default)]
            jurisdiction: Strict<Option<R2Jurisdiction>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            account_id: wire.account_id.0,
            jurisdiction: wire.jurisdiction.0,
        })
    }
}

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

/// S3AccessKey contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct S3AccessKey {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    /// Contract field region.
    #[serde(rename = "region")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    /// Contract field secretAccessKey.
    #[serde(rename = "secretAccessKey")]
    pub secret_access_key: SecretToken,
}
impl<'de> DeserializeStrict<'de> for S3AccessKey {
    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")]
            endpoint: Strict<String>,
            #[serde(rename = "region")]
            #[serde(default)]
            region: Strict<Option<String>>,
            #[serde(rename = "secretAccessKey")]
            secret_access_key: Strict<SecretToken>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            endpoint: wire.endpoint.0,
            region: wire.region.0,
            secret_access_key: wire.secret_access_key.0,
        })
    }
}

/// S3AccessKeyConfig contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct S3AccessKeyConfig {
    /// Contract field accessKeyId.
    #[serde(rename = "accessKeyId")]
    pub access_key_id: String,
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    /// Contract field region.
    #[serde(rename = "region")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
}
impl<'de> DeserializeStrict<'de> for S3AccessKeyConfig {
    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")]
            endpoint: Strict<String>,
            #[serde(rename = "region")]
            #[serde(default)]
            region: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            access_key_id: wire.access_key_id.0,
            endpoint: wire.endpoint.0,
            region: wire.region.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))
    }
}

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

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

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

/// UpdateCredentialRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct UpdateCredentialRequest {
    /// Contract field credential.
    #[serde(rename = "credential")]
    pub credential: Credential,
}
impl<'de> DeserializeStrict<'de> for UpdateCredentialRequest {
    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<Credential>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            credential: wire.credential.0,
        })
    }
}

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

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

/// VendResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct VendResponse {
    /// Contract field credential.
    #[serde(rename = "credential")]
    pub credential: VendedCredential,
}
impl<'de> DeserializeStrict<'de> for VendResponse {
    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),
        })
    }
}

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