spiral-sdk 0.1.11

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

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

use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::Value;
use spiral_contract::error::{ErrorEnvelope, ServiceError};
use spiral_contract::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,
        })
    }
}

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

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

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

/// CreateVectorIndexResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateVectorIndexResponse {
    /// Contract field rootUri.
    #[serde(rename = "rootUri")]
    pub root_uri: String,
    /// Contract field vectorIndexId.
    #[serde(rename = "vectorIndexId")]
    pub vector_index_id: Uuid,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for CreateVectorIndexResponse {
    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 = "vectorIndexId")]
            vector_index_id: Strict<Uuid>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            root_uri: wire.root_uri.0,
            vector_index_id: wire.vector_index_id.0,
            version_id: wire.version_id.0,
        })
    }
}

/// Definition contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Definition {
    /// Contract field dimensions.
    #[serde(rename = "dimensions")]
    pub dimensions: u32,
    /// Contract field engineId.
    #[serde(rename = "engineId")]
    pub engine_id: String,
    /// Contract field engineOptions.
    #[serde(rename = "engineOptions")]
    pub engine_options: BTreeMap<String, String>,
    /// Contract field metric.
    #[serde(rename = "metric")]
    pub metric: DistanceMetric,
    /// Contract field sourceFieldId.
    #[serde(rename = "sourceFieldId")]
    pub source_field_id: Uuid,
    /// Contract field sourceResourceId.
    #[serde(rename = "sourceResourceId")]
    pub source_resource_id: String,
    /// Contract field sourceTableId.
    #[serde(rename = "sourceTableId")]
    pub source_table_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for Definition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "dimensions")]
            dimensions: Strict<u32>,
            #[serde(rename = "engineId")]
            engine_id: Strict<String>,
            #[serde(rename = "engineOptions")]
            engine_options: Strict<BTreeMap<String, String>>,
            #[serde(rename = "metric")]
            metric: Strict<DistanceMetric>,
            #[serde(rename = "sourceFieldId")]
            source_field_id: Strict<Uuid>,
            #[serde(rename = "sourceResourceId")]
            source_resource_id: Strict<String>,
            #[serde(rename = "sourceTableId")]
            source_table_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            dimensions: wire.dimensions.0,
            engine_id: wire.engine_id.0,
            engine_options: wire.engine_options.0,
            metric: wire.metric.0,
            source_field_id: wire.source_field_id.0,
            source_resource_id: wire.source_resource_id.0,
            source_table_id: wire.source_table_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,
        })
    }
}

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

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

/// Codec-owned bytes encoded with the standard base64 alphabet and padding. Large postings remain
/// in object storage.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct IndexMetadata(pub String);
impl std::fmt::Display for IndexMetadata {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for IndexMetadata {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

/// PhysicalState contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PhysicalState {
    /// Contract field codec.
    #[serde(rename = "codec")]
    pub codec: String,
    /// Contract field codecVersion.
    #[serde(rename = "codecVersion")]
    pub codec_version: u32,
    /// Contract field indexedRows.
    #[serde(rename = "indexedRows")]
    pub indexed_rows: SafeUnsignedLong,
    /// Contract field manifestPath.
    #[serde(rename = "manifestPath")]
    pub manifest_path: String,
    /// Contract field metadata.
    #[serde(rename = "metadata")]
    pub metadata: IndexMetadata,
    /// Contract field partitions.
    #[serde(rename = "partitions")]
    pub partitions: u32,
}
impl<'de> DeserializeStrict<'de> for PhysicalState {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "codec")]
            codec: Strict<String>,
            #[serde(rename = "codecVersion")]
            codec_version: Strict<u32>,
            #[serde(rename = "indexedRows")]
            indexed_rows: Strict<SafeUnsignedLong>,
            #[serde(rename = "manifestPath")]
            manifest_path: Strict<String>,
            #[serde(rename = "metadata")]
            metadata: Strict<IndexMetadata>,
            #[serde(rename = "partitions")]
            partitions: Strict<u32>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            codec: wire.codec.0,
            codec_version: wire.codec_version.0,
            indexed_rows: wire.indexed_rows.0,
            manifest_path: wire.manifest_path.0,
            metadata: wire.metadata.0,
            partitions: wire.partitions.0,
        })
    }
}

/// ReadVersionResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReadVersionResponse {
    /// Contract field definition.
    #[serde(rename = "definition")]
    pub definition: Definition,
    /// Contract field rootUri.
    #[serde(rename = "rootUri")]
    pub root_uri: String,
    /// Contract field version.
    #[serde(rename = "version")]
    pub version: Version,
}
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 = "definition")]
            definition: Strict<Definition>,
            #[serde(rename = "rootUri")]
            root_uri: Strict<String>,
            #[serde(rename = "version")]
            version: Strict<Version>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            definition: wire.definition.0,
            root_uri: wire.root_uri.0,
            version: wire.version.0,
        })
    }
}

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

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

/// StorageAccessResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct StorageAccessResponse {
    /// Contract field spfsToken.
    #[serde(rename = "spfsToken")]
    pub spfs_token: SecretToken,
    /// Contract field versionPath.
    #[serde(rename = "versionPath")]
    pub version_path: String,
}
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 = "spfsToken")]
            spfs_token: Strict<SecretToken>,
            #[serde(rename = "versionPath")]
            version_path: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            spfs_token: wire.spfs_token.0,
            version_path: wire.version_path.0,
        })
    }
}

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

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

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

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

/// Version contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Version {
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field parentVersionId.
    #[serde(rename = "parentVersionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_version_id: Option<Uuid>,
    /// Contract field physical.
    #[serde(rename = "physical")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub physical: Option<PhysicalState>,
    /// Contract field sealedAtMicros.
    #[serde(rename = "sealedAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sealed_at_micros: Option<SafeLong>,
    /// Contract field sourceVersionId.
    #[serde(rename = "sourceVersionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_version_id: Option<String>,
    /// Contract field vectorIndexId.
    #[serde(rename = "vectorIndexId")]
    pub vector_index_id: Uuid,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for Version {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "parentVersionId")]
            #[serde(default)]
            parent_version_id: Strict<Option<Uuid>>,
            #[serde(rename = "physical")]
            #[serde(default)]
            physical: Strict<Option<PhysicalState>>,
            #[serde(rename = "sealedAtMicros")]
            #[serde(default)]
            sealed_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "sourceVersionId")]
            #[serde(default)]
            source_version_id: Strict<Option<String>>,
            #[serde(rename = "vectorIndexId")]
            vector_index_id: Strict<Uuid>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            created_at_micros: wire.created_at_micros.0,
            parent_version_id: wire.parent_version_id.0,
            physical: wire.physical.0,
            sealed_at_micros: wire.sealed_at_micros.0,
            source_version_id: wire.source_version_id.0,
            vector_index_id: wire.vector_index_id.0,
            version_id: wire.version_id.0,
        })
    }
}

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

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