spiral-sdk 0.1.12

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Stable identity of a Table.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct TableId(pub Uuid);
impl std::fmt::Display for TableId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for TableId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
    }
}

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

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

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

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

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