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

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

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

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

/// FileSystem contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum FileSystem {
    /// A known union arm.
    Builtin(BuiltinFileSystem),
    /// A known union arm.
    Gcs(GcsFileSystem),
    /// A known union arm.
    R2(R2FileSystem),
    /// A known union arm.
    S3(S3FileSystem),
    /// A known union arm.
    S3Like(S3LikeFileSystem),
    /// A known union arm.
    Upstream(UpstreamFileSystem),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for FileSystem {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Builtin(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("builtin".into()));
                object.insert(
                    "builtin".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Gcs(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("gcs".into()));
                object.insert(
                    "gcs".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::R2(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("r2".into()));
                object.insert(
                    "r2".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::S3(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("s3".into()));
                object.insert(
                    "s3".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::S3Like(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("s3Like".into()));
                object.insert(
                    "s3Like".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Upstream(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("upstream".into()));
                object.insert(
                    "upstream".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 FileSystem {
    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 {
            "builtin" => Ok(Self::Builtin(
                serde_json::from_value(
                    value
                        .get("builtin")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "gcs" => Ok(Self::Gcs(
                serde_json::from_value(
                    value
                        .get("gcs")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "r2" => Ok(Self::R2(
                serde_json::from_value(
                    value
                        .get("r2")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "s3" => Ok(Self::S3(
                serde_json::from_value(
                    value
                        .get("s3")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "s3Like" => Ok(Self::S3Like(
                serde_json::from_value(
                    value
                        .get("s3Like")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "upstream" => Ok(Self::Upstream(
                serde_json::from_value(
                    value
                        .get("upstream")
                        .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 FileSystem {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "builtin")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "builtin")]
            value: Strict<BuiltinFileSystem>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "gcs")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "gcs")]
            value: Strict<GcsFileSystem>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "r2")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "r2")]
            value: Strict<R2FileSystem>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "s3")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "s3")]
            value: Strict<S3FileSystem>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "s3Like")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "s3Like")]
            value: Strict<S3LikeFileSystem>,
        }
        #[derive(Deserialize)]
        enum __Tag5 {
            #[serde(rename = "upstream")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm5 {
            #[serde(rename = "type")]
            _tag: __Tag5,
            #[serde(rename = "upstream")]
            value: Strict<UpstreamFileSystem>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Builtin(Box<__Arm0>),
            Gcs(Box<__Arm1>),
            R2(Box<__Arm2>),
            S3(Box<__Arm3>),
            S3Like(Box<__Arm4>),
            Upstream(Box<__Arm5>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Builtin(arm) => Self::Builtin(arm.value.0),
            __Known::Gcs(arm) => Self::Gcs(arm.value.0),
            __Known::R2(arm) => Self::R2(arm.value.0),
            __Known::S3(arm) => Self::S3(arm.value.0),
            __Known::S3Like(arm) => Self::S3Like(arm.value.0),
            __Known::Upstream(arm) => Self::Upstream(arm.value.0),
        })
    }
}

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

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

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

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

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

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

/// Mount contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Mount {
    /// Contract field alias.
    #[serde(rename = "alias")]
    pub alias: Uuid,
    /// Contract field belongsTo.
    #[serde(rename = "belongsTo")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub belongs_to: Option<String>,
    /// Contract field directory.
    #[serde(rename = "directory")]
    pub directory: String,
    /// Contract field fileSystemId.
    #[serde(rename = "fileSystemId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_system_id: Option<String>,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field mode.
    #[serde(rename = "mode")]
    pub mode: MountMode,
    /// Contract field principal.
    #[serde(rename = "principal")]
    pub principal: String,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
}
impl<'de> DeserializeStrict<'de> for Mount {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "alias")]
            alias: Strict<Uuid>,
            #[serde(rename = "belongsTo")]
            #[serde(default)]
            belongs_to: Strict<Option<String>>,
            #[serde(rename = "directory")]
            directory: Strict<String>,
            #[serde(rename = "fileSystemId")]
            #[serde(default)]
            file_system_id: Strict<Option<String>>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "mode")]
            mode: Strict<MountMode>,
            #[serde(rename = "principal")]
            principal: Strict<String>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            alias: wire.alias.0,
            belongs_to: wire.belongs_to.0,
            directory: wire.directory.0,
            file_system_id: wire.file_system_id.0,
            id: wire.id.0,
            mode: wire.mode.0,
            principal: wire.principal.0,
            project_id: wire.project_id.0,
        })
    }
}

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

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

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

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

/// ProjectStorageFileSystem contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProjectStorageFileSystem {}
impl<'de> DeserializeStrict<'de> for ProjectStorageFileSystem {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {}
        __Wire::deserialize(deserializer)?;
        Ok(Self {})
    }
}

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

/// ProjectStorageViewFileSystem contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProjectStorageViewFileSystem {}
impl<'de> DeserializeStrict<'de> for ProjectStorageViewFileSystem {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {}
        __Wire::deserialize(deserializer)?;
        Ok(Self {})
    }
}

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

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

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

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

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

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

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

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

/// A secret credential or scoped access token.
#[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))
    }
}

/// The outcome of one step of a Volume test.
#[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,
        })
    }
}

/// A Volume test, one entry per step. A refused step is reported as data, not as an error.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TestVolumeResponse {
    /// 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 TestVolumeResponse {
    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,
        })
    }
}

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

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

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

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

/// VolumeIdentity contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct VolumeIdentity {
    /// 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 VolumeIdentity {
    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,
        })
    }
}

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

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

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

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

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

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