spiral-sdk 0.1.11

// 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;

/// A plaintext request credential or a stored vault reference.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AccessKey {
    /// 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 AccessKey {
    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 AccessKey {
    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 AccessKey {
    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),
        })
    }
}

/// How a member signs in. Unclassified means the provider cannot classify the available history.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AuthenticationMethod {
    /// A known contract value.
    Directory,
    /// A known contract value.
    Sso,
    /// A known contract value.
    Password,
    /// A known contract value.
    Unclassified,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for AuthenticationMethod {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Directory => "directory",
            Self::Sso => "sso",
            Self::Password => "password",
            Self::Unclassified => "unclassified",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for AuthenticationMethod {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "directory" => Self::Directory,
            "sso" => Self::Sso,
            "password" => Self::Password,
            "unclassified" => Self::Unclassified,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for AuthenticationMethod {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "directory")]
            Directory,
            #[serde(rename = "sso")]
            Sso,
            #[serde(rename = "password")]
            Password,
            #[serde(rename = "unclassified")]
            Unclassified,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Directory => Self::Directory,
            __Known::Sso => Self::Sso,
            __Known::Password => Self::Password,
            __Known::Unclassified => Self::Unclassified,
        })
    }
}

/// An operator-configured managed storage provider.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuiltinStorage {
    /// Contract field directory.
    #[serde(rename = "directory")]
    pub directory: String,
    /// Contract field provider.
    #[serde(rename = "provider")]
    pub provider: String,
}
impl<'de> DeserializeStrict<'de> for BuiltinStorage {
    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,
        })
    }
}

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

/// The Organization created in the identity provider. Webhook synchronization creates local
/// membership state.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateOrganizationResponse {
    /// Contract field organization.
    #[serde(rename = "organization")]
    pub organization: Organization,
}
impl<'de> DeserializeStrict<'de> for CreateOrganizationResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "organization")]
            organization: Strict<Organization>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            organization: wire.organization.0,
        })
    }
}

/// Storage for newly created Projects. Changing this default does not move existing Projects.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum DefaultFilesystem {
    /// A known union arm.
    Disabled(Empty),
    /// A known union arm.
    Filesystem(Filesystem),
    /// A known union arm.
    Managed(Empty),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for DefaultFilesystem {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Disabled(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("disabled".into()));
                object.insert(
                    "disabled".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            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::Managed(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("managed".into()));
                object.insert(
                    "managed".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 DefaultFilesystem {
    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 {
            "disabled" => Ok(Self::Disabled(
                serde_json::from_value(
                    value
                        .get("disabled")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "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)?,
            )),
            "managed" => Ok(Self::Managed(
                serde_json::from_value(
                    value
                        .get("managed")
                        .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 DefaultFilesystem {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "disabled")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "disabled")]
            value: Strict<Empty>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "filesystem")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "filesystem")]
            value: Strict<Filesystem>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "managed")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "managed")]
            value: Strict<Empty>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Disabled(Box<__Arm0>),
            Filesystem(Box<__Arm1>),
            Managed(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Disabled(arm) => Self::Disabled(arm.value.0),
            __Known::Filesystem(arm) => Self::Filesystem(arm.value.0),
            __Known::Managed(arm) => Self::Managed(arm.value.0),
        })
    }
}

/// No additional configuration.
#[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 {})
    }
}

/// A typed storage template. Storage validation and secret handling remain storage-service
/// operations.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Filesystem {
    /// A known union arm.
    Builtin(BuiltinStorage),
    /// A known union arm.
    Gcs(GcsStorage),
    /// A known union arm.
    R2(R2Storage),
    /// A known union arm.
    S3(S3Storage),
    /// A known union arm.
    S3Compatible(S3CompatibleStorage),
    /// A known union arm.
    Upstream(UpstreamStorage),
    /// 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::S3Compatible(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("s3Compatible".into()));
                object.insert(
                    "s3Compatible".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)?,
            )),
            "s3Compatible" => Ok(Self::S3Compatible(
                serde_json::from_value(
                    value
                        .get("s3Compatible")
                        .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<BuiltinStorage>,
        }
        #[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<GcsStorage>,
        }
        #[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<R2Storage>,
        }
        #[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<S3Storage>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "s3Compatible")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "s3Compatible")]
            value: Strict<S3CompatibleStorage>,
        }
        #[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<UpstreamStorage>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Builtin(Box<__Arm0>),
            Gcs(Box<__Arm1>),
            R2(Box<__Arm2>),
            S3(Box<__Arm3>),
            S3Compatible(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::S3Compatible(arm) => Self::S3Compatible(arm.value.0),
            __Known::Upstream(arm) => Self::Upstream(arm.value.0),
        })
    }
}

/// An existing Google Cloud Storage template. New templates remain subject to the storage service
/// policy.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct GcsStorage {
    /// 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 GcsStorage {
    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,
        })
    }
}

/// The authenticated user and active Organization. Requires a first-party user credential.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Identity {
    /// Contract field email.
    #[serde(rename = "email")]
    pub email: String,
    /// Contract field emailVerified.
    #[serde(rename = "emailVerified")]
    pub email_verified: bool,
    /// Contract field firstName.
    #[serde(rename = "firstName")]
    pub first_name: String,
    /// Contract field lastName.
    #[serde(rename = "lastName")]
    pub last_name: String,
    /// Contract field organizationId.
    #[serde(rename = "organizationId")]
    pub organization_id: String,
    /// Contract field organizationName.
    #[serde(rename = "organizationName")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub organization_name: Option<String>,
    /// Contract field role.
    #[serde(rename = "role")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    /// Contract field userId.
    #[serde(rename = "userId")]
    pub user_id: String,
}
impl<'de> DeserializeStrict<'de> for Identity {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "email")]
            email: Strict<String>,
            #[serde(rename = "emailVerified")]
            email_verified: Strict<bool>,
            #[serde(rename = "firstName")]
            first_name: Strict<String>,
            #[serde(rename = "lastName")]
            last_name: Strict<String>,
            #[serde(rename = "organizationId")]
            organization_id: Strict<String>,
            #[serde(rename = "organizationName")]
            #[serde(default)]
            organization_name: Strict<Option<String>>,
            #[serde(rename = "role")]
            #[serde(default)]
            role: Strict<Option<String>>,
            #[serde(rename = "userId")]
            user_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            email: wire.email.0,
            email_verified: wire.email_verified.0,
            first_name: wire.first_name.0,
            last_name: wire.last_name.0,
            organization_id: wire.organization_id.0,
            organization_name: wire.organization_name.0,
            role: wire.role.0,
            user_id: wire.user_id.0,
        })
    }
}

/// An invitation owned by the active Organization.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Invitation {
    /// Contract field acceptedAt.
    #[serde(rename = "acceptedAt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accepted_at: Option<String>,
    /// Contract field createdAt.
    #[serde(rename = "createdAt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    /// Contract field email.
    #[serde(rename = "email")]
    pub email: String,
    /// Contract field expiresAt.
    #[serde(rename = "expiresAt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field inviterUserId.
    #[serde(rename = "inviterUserId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub inviter_user_id: Option<String>,
    /// Contract field role.
    #[serde(rename = "role")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<OrganizationRole>,
    /// Contract field state.
    #[serde(rename = "state")]
    pub state: String,
}
impl<'de> DeserializeStrict<'de> for Invitation {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "acceptedAt")]
            #[serde(default)]
            accepted_at: Strict<Option<String>>,
            #[serde(rename = "createdAt")]
            #[serde(default)]
            created_at: Strict<Option<String>>,
            #[serde(rename = "email")]
            email: Strict<String>,
            #[serde(rename = "expiresAt")]
            #[serde(default)]
            expires_at: Strict<Option<String>>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "inviterUserId")]
            #[serde(default)]
            inviter_user_id: Strict<Option<String>>,
            #[serde(rename = "role")]
            #[serde(default)]
            role: Strict<Option<OrganizationRole>>,
            #[serde(rename = "state")]
            state: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            accepted_at: wire.accepted_at.0,
            created_at: wire.created_at.0,
            email: wire.email.0,
            expires_at: wire.expires_at.0,
            id: wire.id.0,
            inviter_user_id: wire.inviter_user_id.0,
            role: wire.role.0,
            state: wire.state.0,
        })
    }
}

/// Live invitations in descending provider invitation ID order.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InvitationPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<Invitation>,
    /// 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 InvitationPage {
    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<Invitation>>,
            #[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,
        })
    }
}

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

/// Invite a user with an Organization role and optional invitation lifetime.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InviteMemberRequest {
    /// Contract field email.
    #[serde(rename = "email")]
    pub email: String,
    /// Contract field expiresInDays.
    #[serde(rename = "expiresInDays")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_in_days: Option<i32>,
    /// Contract field role.
    #[serde(rename = "role")]
    pub role: OrganizationRole,
}
impl<'de> DeserializeStrict<'de> for InviteMemberRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "email")]
            email: Strict<String>,
            #[serde(rename = "expiresInDays")]
            #[serde(default)]
            expires_in_days: Strict<Option<i32>>,
            #[serde(rename = "role")]
            role: Strict<OrganizationRole>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            email: wire.email.0,
            expires_in_days: wire.expires_in_days.0,
            role: wire.role.0,
        })
    }
}

/// Live provider membership listing in descending provider membership ID order. Page size defaults
/// to 10 and must be 1..=100. Continuations expire after one hour and bind the credential and page
/// size.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListMembersRequest {
    /// 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 ListMembersRequest {
    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,
        })
    }
}

/// Live continuation request. Page size defaults to 100 and must be 1..=1000. Tokens expire after
/// one hour and are bound to the credential, operation, filters and page size.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListMembershipsRequest {
    /// 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 ListMembershipsRequest {
    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,
        })
    }
}

/// Filter Organizations by active status. Page size defaults to 100 and must be 1..=1000.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListOrganizationsRequest {
    /// Contract field active.
    #[serde(rename = "active")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,
    /// 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 ListOrganizationsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "active")]
            #[serde(default)]
            active: Strict<Option<bool>>,
            #[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 {
            active: wire.active.0,
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
        })
    }
}

/// An Organization member and provider profile.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Member {
    /// Contract field authMethod.
    #[serde(rename = "authMethod")]
    pub auth_method: AuthenticationMethod,
    /// Contract field createdAt.
    #[serde(rename = "createdAt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    /// Contract field email.
    #[serde(rename = "email")]
    pub email: String,
    /// Contract field emailVerified.
    #[serde(rename = "emailVerified")]
    pub email_verified: bool,
    /// Contract field firstName.
    #[serde(rename = "firstName")]
    pub first_name: String,
    /// Contract field lastName.
    #[serde(rename = "lastName")]
    pub last_name: String,
    /// Contract field lastSignInAt.
    #[serde(rename = "lastSignInAt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_sign_in_at: Option<String>,
    /// Contract field profilePictureUrl.
    #[serde(rename = "profilePictureUrl")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub profile_picture_url: Option<String>,
    /// Contract field role.
    #[serde(rename = "role")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<OrganizationRole>,
    /// Contract field userId.
    #[serde(rename = "userId")]
    pub user_id: String,
}
impl<'de> DeserializeStrict<'de> for Member {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "authMethod")]
            auth_method: Strict<AuthenticationMethod>,
            #[serde(rename = "createdAt")]
            #[serde(default)]
            created_at: Strict<Option<String>>,
            #[serde(rename = "email")]
            email: Strict<String>,
            #[serde(rename = "emailVerified")]
            email_verified: Strict<bool>,
            #[serde(rename = "firstName")]
            first_name: Strict<String>,
            #[serde(rename = "lastName")]
            last_name: Strict<String>,
            #[serde(rename = "lastSignInAt")]
            #[serde(default)]
            last_sign_in_at: Strict<Option<String>>,
            #[serde(rename = "profilePictureUrl")]
            #[serde(default)]
            profile_picture_url: Strict<Option<String>>,
            #[serde(rename = "role")]
            #[serde(default)]
            role: Strict<Option<OrganizationRole>>,
            #[serde(rename = "userId")]
            user_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            auth_method: wire.auth_method.0,
            created_at: wire.created_at.0,
            email: wire.email.0,
            email_verified: wire.email_verified.0,
            first_name: wire.first_name.0,
            last_name: wire.last_name.0,
            last_sign_in_at: wire.last_sign_in_at.0,
            profile_picture_url: wire.profile_picture_url.0,
            role: wire.role.0,
            user_id: wire.user_id.0,
        })
    }
}

/// One live provider page of Organization members.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct MemberPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<Member>,
    /// 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 MemberPage {
    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<Member>>,
            #[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,
        })
    }
}

/// One user membership in an Organization.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Membership {
    /// Contract field organization.
    #[serde(rename = "organization")]
    pub organization: Organization,
    /// Contract field role.
    #[serde(rename = "role")]
    pub role: OrganizationRole,
    /// Contract field userId.
    #[serde(rename = "userId")]
    pub user_id: String,
}
impl<'de> DeserializeStrict<'de> for Membership {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "organization")]
            organization: Strict<Organization>,
            #[serde(rename = "role")]
            role: Strict<OrganizationRole>,
            #[serde(rename = "userId")]
            user_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            organization: wire.organization.0,
            role: wire.role.0,
            user_id: wire.user_id.0,
        })
    }
}

/// Live memberships ordered by Organization ID for the caller, or by provider membership ID for
/// synchronization.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct MembershipPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<Membership>,
    /// 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 MembershipPage {
    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<Membership>>,
            #[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,
        })
    }
}

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

/// Organization storage policy. Only Organization owners may read or write the full configuration.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrganizationConfig {
    /// Contract field defaultFilesystem.
    #[serde(rename = "defaultFilesystem")]
    pub default_filesystem: DefaultFilesystem,
}
impl<'de> DeserializeStrict<'de> for OrganizationConfig {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "defaultFilesystem")]
            default_filesystem: Strict<DefaultFilesystem>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            default_filesystem: wire.default_filesystem.0,
        })
    }
}

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

/// The Organization identities synchronized by one provider page, in descending provider ID order.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrganizationIdPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<String>,
    /// 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 OrganizationIdPage {
    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<String>>,
            #[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,
        })
    }
}

/// Live administrative Organization records ordered by ID.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrganizationPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<OrganizationDetails>,
    /// 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 OrganizationPage {
    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<OrganizationDetails>>,
            #[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,
        })
    }
}

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

/// The account setting to open in the administration portal.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PortalIntent {
    /// A known contract value.
    Sso,
    /// A known contract value.
    DirectorySync,
    /// A known contract value.
    AuditLogs,
    /// A known contract value.
    LogStreams,
    /// A known contract value.
    DomainVerification,
    /// A known contract value.
    BringYourOwnKey,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for PortalIntent {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Sso => "sso",
            Self::DirectorySync => "directory_sync",
            Self::AuditLogs => "audit_logs",
            Self::LogStreams => "log_streams",
            Self::DomainVerification => "domain_verification",
            Self::BringYourOwnKey => "bring_your_own_key",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for PortalIntent {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "sso" => Self::Sso,
            "directory_sync" => Self::DirectorySync,
            "audit_logs" => Self::AuditLogs,
            "log_streams" => Self::LogStreams,
            "domain_verification" => Self::DomainVerification,
            "bring_your_own_key" => Self::BringYourOwnKey,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for PortalIntent {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "sso")]
            Sso,
            #[serde(rename = "directory_sync")]
            DirectorySync,
            #[serde(rename = "audit_logs")]
            AuditLogs,
            #[serde(rename = "log_streams")]
            LogStreams,
            #[serde(rename = "domain_verification")]
            DomainVerification,
            #[serde(rename = "bring_your_own_key")]
            BringYourOwnKey,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Sso => Self::Sso,
            __Known::DirectorySync => Self::DirectorySync,
            __Known::AuditLogs => Self::AuditLogs,
            __Known::LogStreams => Self::LogStreams,
            __Known::DomainVerification => Self::DomainVerification,
            __Known::BringYourOwnKey => Self::BringYourOwnKey,
        })
    }
}

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

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

/// R2 storage with an access key.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct R2Storage {
    /// 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: AccessKey,
}
impl<'de> DeserializeStrict<'de> for R2Storage {
    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<AccessKey>,
        }
        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,
        })
    }
}

/// S3-compatible storage with an access key.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct S3CompatibleStorage {
    /// 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: AccessKey,
}
impl<'de> DeserializeStrict<'de> for S3CompatibleStorage {
    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<AccessKey>,
        }
        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,
        })
    }
}

/// S3 storage using an IAM role.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct S3Storage {
    /// 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 S3Storage {
    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,
        })
    }
}

/// Plaintext credential supplied only in a request. Stored credentials become vault references.
#[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 role to assign. The last owner cannot be demoted.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SetMemberRoleRequest {
    /// Contract field role.
    #[serde(rename = "role")]
    pub role: OrganizationRole,
}
impl<'de> DeserializeStrict<'de> for SetMemberRoleRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "role")]
            role: Strict<OrganizationRole>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { role: wire.role.0 })
    }
}

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

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