impl serde::Serialize for AccessToken {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("acme.user.v1.AccessToken", len)?;
        if true {
            struct_ser.serialize_field("id", &self.id)?;
        }
        if let Some(v) = self.description.as_ref() {
            struct_ser.serialize_field("description", v)?;
        }
        if let Some(v) = self.expires_at.as_ref() {
            struct_ser.serialize_field("expiresAt", v)?;
        }
        if let Some(v) = self.expires_in.as_ref() {
            struct_ser.serialize_field("expiresIn", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for AccessToken {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "id",
            "description",
            "expires_at",
            "expiresAt",
            "expires_in",
            "expiresIn",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Id,
            Description,
            ExpiresAt,
            ExpiresIn,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;

                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;

                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", &FIELDS)
                    }

                    #[allow(unused_variables)]
                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "id" => Ok(GeneratedField::Id),
                            "description" => Ok(GeneratedField::Description),
                            "expiresAt" | "expires_at" => Ok(GeneratedField::ExpiresAt),
                            "expiresIn" | "expires_in" => Ok(GeneratedField::ExpiresIn),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = AccessToken;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct acme.user.v1.AccessToken")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AccessToken, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut id__ = None;
                let mut description__ = None;
                let mut expires_at__ = None;
                let mut expires_in__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Id => {
                            if id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("id"));
                            }
                            id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Description => {
                            if description__.is_some() {
                                return Err(serde::de::Error::duplicate_field("description"));
                            }
                            description__ = map_.next_value()?;
                        }
                        GeneratedField::ExpiresAt => {
                            if expires_at__.is_some() {
                                return Err(serde::de::Error::duplicate_field("expiresAt"));
                            }
                            expires_at__ = map_.next_value()?;
                        }
                        GeneratedField::ExpiresIn => {
                            if expires_in__.is_some() {
                                return Err(serde::de::Error::duplicate_field("expiresIn"));
                            }
                            expires_in__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(AccessToken {
                    id: id__.unwrap_or_default(),
                    description: description__,
                    expires_at: expires_at__,
                    expires_in: expires_in__,
                })
            }
        }
        deserializer.deserialize_struct("acme.user.v1.AccessToken", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for Account {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if self.owner.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("acme.user.v1.Account", len)?;
        if true {
            struct_ser.serialize_field("id", &self.id)?;
        }
        if let Some(v) = self.name.as_ref() {
            struct_ser.serialize_field("name", v)?;
        }
        if let Some(v) = self.email.as_ref() {
            struct_ser.serialize_field("email", v)?;
        }
        if let Some(v) = self.metadata.as_ref() {
            struct_ser.serialize_field("metadata", v)?;
        }
        if true {
            struct_ser.serialize_field("linkedAccountIds", &self.linked_account_ids)?;
        }
        if let Some(v) = self.created_at.as_ref() {
            struct_ser.serialize_field("createdAt", v)?;
        }
        if let Some(v) = self.created_by_account_id.as_ref() {
            struct_ser.serialize_field("createdByAccountId", v)?;
        }
        if let Some(v) = self.deleted_at.as_ref() {
            struct_ser.serialize_field("deletedAt", v)?;
        }
        if let Some(v) = self.deleted_by_account_id.as_ref() {
            struct_ser.serialize_field("deletedByAccountId", v)?;
        }
        if let Some(v) = self.updated_at.as_ref() {
            struct_ser.serialize_field("updatedAt", v)?;
        }
        if let Some(v) = self.updated_by_account_id.as_ref() {
            struct_ser.serialize_field("updatedByAccountId", v)?;
        }
        if let Some(v) = self.owner.as_ref() {
            match v {
                account::Owner::OwnerAccountId(v) => {
                    struct_ser.serialize_field("ownerAccountId", v)?;
                }
            }
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for Account {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "id",
            "name",
            "email",
            "metadata",
            "linked_account_ids",
            "linkedAccountIds",
            "created_at",
            "createdAt",
            "created_by_account_id",
            "createdByAccountId",
            "deleted_at",
            "deletedAt",
            "deleted_by_account_id",
            "deletedByAccountId",
            "updated_at",
            "updatedAt",
            "updated_by_account_id",
            "updatedByAccountId",
            "owner_account_id",
            "ownerAccountId",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Id,
            Name,
            Email,
            Metadata,
            LinkedAccountIds,
            CreatedAt,
            CreatedByAccountId,
            DeletedAt,
            DeletedByAccountId,
            UpdatedAt,
            UpdatedByAccountId,
            OwnerAccountId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;

                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;

                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", &FIELDS)
                    }

                    #[allow(unused_variables)]
                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "id" => Ok(GeneratedField::Id),
                            "name" => Ok(GeneratedField::Name),
                            "email" => Ok(GeneratedField::Email),
                            "metadata" => Ok(GeneratedField::Metadata),
                            "linkedAccountIds" | "linked_account_ids" => Ok(GeneratedField::LinkedAccountIds),
                            "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt),
                            "createdByAccountId" | "created_by_account_id" => Ok(GeneratedField::CreatedByAccountId),
                            "deletedAt" | "deleted_at" => Ok(GeneratedField::DeletedAt),
                            "deletedByAccountId" | "deleted_by_account_id" => Ok(GeneratedField::DeletedByAccountId),
                            "updatedAt" | "updated_at" => Ok(GeneratedField::UpdatedAt),
                            "updatedByAccountId" | "updated_by_account_id" => Ok(GeneratedField::UpdatedByAccountId),
                            "ownerAccountId" | "owner_account_id" => Ok(GeneratedField::OwnerAccountId),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = Account;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct acme.user.v1.Account")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Account, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut id__ = None;
                let mut name__ = None;
                let mut email__ = None;
                let mut metadata__ = None;
                let mut linked_account_ids__ = None;
                let mut created_at__ = None;
                let mut created_by_account_id__ = None;
                let mut deleted_at__ = None;
                let mut deleted_by_account_id__ = None;
                let mut updated_at__ = None;
                let mut updated_by_account_id__ = None;
                let mut owner__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Id => {
                            if id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("id"));
                            }
                            id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = map_.next_value()?;
                        }
                        GeneratedField::Email => {
                            if email__.is_some() {
                                return Err(serde::de::Error::duplicate_field("email"));
                            }
                            email__ = map_.next_value()?;
                        }
                        GeneratedField::Metadata => {
                            if metadata__.is_some() {
                                return Err(serde::de::Error::duplicate_field("metadata"));
                            }
                            metadata__ = map_.next_value()?;
                        }
                        GeneratedField::LinkedAccountIds => {
                            if linked_account_ids__.is_some() {
                                return Err(serde::de::Error::duplicate_field("linkedAccountIds"));
                            }
                            linked_account_ids__ = Some(map_.next_value()?);
                        }
                        GeneratedField::CreatedAt => {
                            if created_at__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createdAt"));
                            }
                            created_at__ = map_.next_value()?;
                        }
                        GeneratedField::CreatedByAccountId => {
                            if created_by_account_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createdByAccountId"));
                            }
                            created_by_account_id__ = map_.next_value()?;
                        }
                        GeneratedField::DeletedAt => {
                            if deleted_at__.is_some() {
                                return Err(serde::de::Error::duplicate_field("deletedAt"));
                            }
                            deleted_at__ = map_.next_value()?;
                        }
                        GeneratedField::DeletedByAccountId => {
                            if deleted_by_account_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("deletedByAccountId"));
                            }
                            deleted_by_account_id__ = map_.next_value()?;
                        }
                        GeneratedField::UpdatedAt => {
                            if updated_at__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updatedAt"));
                            }
                            updated_at__ = map_.next_value()?;
                        }
                        GeneratedField::UpdatedByAccountId => {
                            if updated_by_account_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updatedByAccountId"));
                            }
                            updated_by_account_id__ = map_.next_value()?;
                        }
                        GeneratedField::OwnerAccountId => {
                            if owner__.is_some() {
                                return Err(serde::de::Error::duplicate_field("ownerAccountId"));
                            }
                            owner__ = map_.next_value::<::std::option::Option<_>>()?.map(account::Owner::OwnerAccountId);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(Account {
                    id: id__.unwrap_or_default(),
                    name: name__,
                    email: email__,
                    metadata: metadata__,
                    linked_account_ids: linked_account_ids__.unwrap_or_default(),
                    created_at: created_at__,
                    created_by_account_id: created_by_account_id__,
                    deleted_at: deleted_at__,
                    deleted_by_account_id: deleted_by_account_id__,
                    updated_at: updated_at__,
                    updated_by_account_id: updated_by_account_id__,
                    owner: owner__,
                })
            }
        }
        deserializer.deserialize_struct("acme.user.v1.Account", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for LinkedAccount {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if self.owner.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("acme.user.v1.LinkedAccount", len)?;
        if true {
            struct_ser.serialize_field("id", &self.id)?;
        }
        if true {
            let v = linked_account::Type::try_from(self.r#type)
                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
            struct_ser.serialize_field("type", &v)?;
        }
        if true {
            let v = linked_account::Provider::try_from(self.provider)
                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
            struct_ser.serialize_field("provider", &v)?;
        }
        if true {
            struct_ser.serialize_field("providerUid", &self.provider_uid)?;
        }
        if let Some(v) = self.metadata.as_ref() {
            struct_ser.serialize_field("metadata", v)?;
        }
        if let Some(v) = self.created_at.as_ref() {
            struct_ser.serialize_field("createdAt", v)?;
        }
        if let Some(v) = self.created_by_account_id.as_ref() {
            struct_ser.serialize_field("createdByAccountId", v)?;
        }
        if let Some(v) = self.deleted_at.as_ref() {
            struct_ser.serialize_field("deletedAt", v)?;
        }
        if let Some(v) = self.deleted_by_account_id.as_ref() {
            struct_ser.serialize_field("deletedByAccountId", v)?;
        }
        if let Some(v) = self.updated_at.as_ref() {
            struct_ser.serialize_field("updatedAt", v)?;
        }
        if let Some(v) = self.updated_by_account_id.as_ref() {
            struct_ser.serialize_field("updatedByAccountId", v)?;
        }
        if let Some(v) = self.owner.as_ref() {
            match v {
                linked_account::Owner::OwnerAccountId(v) => {
                    struct_ser.serialize_field("ownerAccountId", v)?;
                }
            }
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for LinkedAccount {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "id",
            "type",
            "provider",
            "provider_uid",
            "providerUid",
            "metadata",
            "created_at",
            "createdAt",
            "created_by_account_id",
            "createdByAccountId",
            "deleted_at",
            "deletedAt",
            "deleted_by_account_id",
            "deletedByAccountId",
            "updated_at",
            "updatedAt",
            "updated_by_account_id",
            "updatedByAccountId",
            "owner_account_id",
            "ownerAccountId",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Id,
            Type,
            Provider,
            ProviderUid,
            Metadata,
            CreatedAt,
            CreatedByAccountId,
            DeletedAt,
            DeletedByAccountId,
            UpdatedAt,
            UpdatedByAccountId,
            OwnerAccountId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;

                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;

                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", &FIELDS)
                    }

                    #[allow(unused_variables)]
                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "id" => Ok(GeneratedField::Id),
                            "type" => Ok(GeneratedField::Type),
                            "provider" => Ok(GeneratedField::Provider),
                            "providerUid" | "provider_uid" => Ok(GeneratedField::ProviderUid),
                            "metadata" => Ok(GeneratedField::Metadata),
                            "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt),
                            "createdByAccountId" | "created_by_account_id" => Ok(GeneratedField::CreatedByAccountId),
                            "deletedAt" | "deleted_at" => Ok(GeneratedField::DeletedAt),
                            "deletedByAccountId" | "deleted_by_account_id" => Ok(GeneratedField::DeletedByAccountId),
                            "updatedAt" | "updated_at" => Ok(GeneratedField::UpdatedAt),
                            "updatedByAccountId" | "updated_by_account_id" => Ok(GeneratedField::UpdatedByAccountId),
                            "ownerAccountId" | "owner_account_id" => Ok(GeneratedField::OwnerAccountId),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = LinkedAccount;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct acme.user.v1.LinkedAccount")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LinkedAccount, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut id__ = None;
                let mut r#type__ = None;
                let mut provider__ = None;
                let mut provider_uid__ = None;
                let mut metadata__ = None;
                let mut created_at__ = None;
                let mut created_by_account_id__ = None;
                let mut deleted_at__ = None;
                let mut deleted_by_account_id__ = None;
                let mut updated_at__ = None;
                let mut updated_by_account_id__ = None;
                let mut owner__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Id => {
                            if id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("id"));
                            }
                            id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Type => {
                            if r#type__.is_some() {
                                return Err(serde::de::Error::duplicate_field("type"));
                            }
                            r#type__ = Some(map_.next_value::<linked_account::Type>()? as i32);
                        }
                        GeneratedField::Provider => {
                            if provider__.is_some() {
                                return Err(serde::de::Error::duplicate_field("provider"));
                            }
                            provider__ = Some(map_.next_value::<linked_account::Provider>()? as i32);
                        }
                        GeneratedField::ProviderUid => {
                            if provider_uid__.is_some() {
                                return Err(serde::de::Error::duplicate_field("providerUid"));
                            }
                            provider_uid__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Metadata => {
                            if metadata__.is_some() {
                                return Err(serde::de::Error::duplicate_field("metadata"));
                            }
                            metadata__ = map_.next_value()?;
                        }
                        GeneratedField::CreatedAt => {
                            if created_at__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createdAt"));
                            }
                            created_at__ = map_.next_value()?;
                        }
                        GeneratedField::CreatedByAccountId => {
                            if created_by_account_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createdByAccountId"));
                            }
                            created_by_account_id__ = map_.next_value()?;
                        }
                        GeneratedField::DeletedAt => {
                            if deleted_at__.is_some() {
                                return Err(serde::de::Error::duplicate_field("deletedAt"));
                            }
                            deleted_at__ = map_.next_value()?;
                        }
                        GeneratedField::DeletedByAccountId => {
                            if deleted_by_account_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("deletedByAccountId"));
                            }
                            deleted_by_account_id__ = map_.next_value()?;
                        }
                        GeneratedField::UpdatedAt => {
                            if updated_at__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updatedAt"));
                            }
                            updated_at__ = map_.next_value()?;
                        }
                        GeneratedField::UpdatedByAccountId => {
                            if updated_by_account_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updatedByAccountId"));
                            }
                            updated_by_account_id__ = map_.next_value()?;
                        }
                        GeneratedField::OwnerAccountId => {
                            if owner__.is_some() {
                                return Err(serde::de::Error::duplicate_field("ownerAccountId"));
                            }
                            owner__ = map_.next_value::<::std::option::Option<_>>()?.map(linked_account::Owner::OwnerAccountId);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(LinkedAccount {
                    id: id__.unwrap_or_default(),
                    r#type: r#type__.unwrap_or_default(),
                    provider: provider__.unwrap_or_default(),
                    provider_uid: provider_uid__.unwrap_or_default(),
                    metadata: metadata__,
                    created_at: created_at__,
                    created_by_account_id: created_by_account_id__,
                    deleted_at: deleted_at__,
                    deleted_by_account_id: deleted_by_account_id__,
                    updated_at: updated_at__,
                    updated_by_account_id: updated_by_account_id__,
                    owner: owner__,
                })
            }
        }
        deserializer.deserialize_struct("acme.user.v1.LinkedAccount", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for linked_account::Provider {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let variant = match self {
            Self::GitHub => "GitHub",
            Self::GitLab => "GitLab",
            Self::Stripe => "Stripe",
            Self::Google => "Google",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for linked_account::Provider {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "GitHub",
            "GitLab",
            "Stripe",
            "Google",
        ];

        struct GeneratedVisitor;

        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = linked_account::Provider;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(formatter, "expected one of: {:?}", &FIELDS)
            }

            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| x.try_into().ok())
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                    })
            }

            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| x.try_into().ok())
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                    })
            }

            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                match value {
                    "GitHub" => Ok(linked_account::Provider::GitHub),
                    "GitLab" => Ok(linked_account::Provider::GitLab),
                    "Stripe" => Ok(linked_account::Provider::Stripe),
                    "Google" => Ok(linked_account::Provider::Google),
                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for linked_account::Type {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let variant = match self {
            Self::IdentityProvider => "IdentityProvider",
            Self::PaymentProvider => "PaymentProvider",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for linked_account::Type {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "IdentityProvider",
            "PaymentProvider",
        ];

        struct GeneratedVisitor;

        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = linked_account::Type;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(formatter, "expected one of: {:?}", &FIELDS)
            }

            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| x.try_into().ok())
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                    })
            }

            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| x.try_into().ok())
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                    })
            }

            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                match value {
                    "IdentityProvider" => Ok(linked_account::Type::IdentityProvider),
                    "PaymentProvider" => Ok(linked_account::Type::PaymentProvider),
                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for TypeSaladBooleanType {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if true {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("acme.user.v1.TypeSaladBooleanType", len)?;
        if true {
            struct_ser.serialize_field("col1", &self.col_1)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for TypeSaladBooleanType {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "col_1",
            "col1",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Col1,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;

                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;

                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", &FIELDS)
                    }

                    #[allow(unused_variables)]
                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "col1" | "col_1" => Ok(GeneratedField::Col1),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = TypeSaladBooleanType;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct acme.user.v1.TypeSaladBooleanType")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TypeSaladBooleanType, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut col_1__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Col1 => {
                            if col_1__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col1"));
                            }
                            col_1__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(TypeSaladBooleanType {
                    col_1: col_1__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("acme.user.v1.TypeSaladBooleanType", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for TypeSaladCharacterTypes {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("acme.user.v1.TypeSaladCharacterTypes", len)?;
        if true {
            struct_ser.serialize_field("col1", &self.col_1)?;
        }
        if true {
            struct_ser.serialize_field("col2", &self.col_2)?;
        }
        if true {
            struct_ser.serialize_field("col3", &self.col_3)?;
        }
        if true {
            struct_ser.serialize_field("col4", &self.col_4)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for TypeSaladCharacterTypes {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "col_1",
            "col1",
            "col_2",
            "col2",
            "col_3",
            "col3",
            "col_4",
            "col4",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Col1,
            Col2,
            Col3,
            Col4,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;

                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;

                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", &FIELDS)
                    }

                    #[allow(unused_variables)]
                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "col1" | "col_1" => Ok(GeneratedField::Col1),
                            "col2" | "col_2" => Ok(GeneratedField::Col2),
                            "col3" | "col_3" => Ok(GeneratedField::Col3),
                            "col4" | "col_4" => Ok(GeneratedField::Col4),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = TypeSaladCharacterTypes;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct acme.user.v1.TypeSaladCharacterTypes")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TypeSaladCharacterTypes, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut col_1__ = None;
                let mut col_2__ = None;
                let mut col_3__ = None;
                let mut col_4__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Col1 => {
                            if col_1__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col1"));
                            }
                            col_1__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Col2 => {
                            if col_2__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col2"));
                            }
                            col_2__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Col3 => {
                            if col_3__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col3"));
                            }
                            col_3__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Col4 => {
                            if col_4__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col4"));
                            }
                            col_4__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(TypeSaladCharacterTypes {
                    col_1: col_1__.unwrap_or_default(),
                    col_2: col_2__.unwrap_or_default(),
                    col_3: col_3__.unwrap_or_default(),
                    col_4: col_4__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("acme.user.v1.TypeSaladCharacterTypes", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for TypeSaladNumericFloatingPointTypes {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("acme.user.v1.TypeSaladNumericFloatingPointTypes", len)?;
        if true {
            struct_ser.serialize_field("id", &self.id)?;
        }
        if true {
            struct_ser.serialize_field("col2", &self.col_2)?;
        }
        if true {
            struct_ser.serialize_field("col3", &self.col_3)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for TypeSaladNumericFloatingPointTypes {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "id",
            "col_2",
            "col2",
            "col_3",
            "col3",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Id,
            Col2,
            Col3,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;

                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;

                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", &FIELDS)
                    }

                    #[allow(unused_variables)]
                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "id" => Ok(GeneratedField::Id),
                            "col2" | "col_2" => Ok(GeneratedField::Col2),
                            "col3" | "col_3" => Ok(GeneratedField::Col3),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = TypeSaladNumericFloatingPointTypes;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct acme.user.v1.TypeSaladNumericFloatingPointTypes")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TypeSaladNumericFloatingPointTypes, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut id__ = None;
                let mut col_2__ = None;
                let mut col_3__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Id => {
                            if id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("id"));
                            }
                            id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Col2 => {
                            if col_2__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col2"));
                            }
                            col_2__ = 
                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                            ;
                        }
                        GeneratedField::Col3 => {
                            if col_3__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col3"));
                            }
                            col_3__ = 
                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                            ;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(TypeSaladNumericFloatingPointTypes {
                    id: id__.unwrap_or_default(),
                    col_2: col_2__.unwrap_or_default(),
                    col_3: col_3__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("acme.user.v1.TypeSaladNumericFloatingPointTypes", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for TypeSaladNumericIntegerTypes {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        if true {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("acme.user.v1.TypeSaladNumericIntegerTypes", len)?;
        if true {
            struct_ser.serialize_field("id", &self.id)?;
        }
        if true {
            struct_ser.serialize_field("col2", &self.col_2)?;
        }
        if true {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser.serialize_field("col3", ToString::to_string(&self.col_3).as_str())?;
        }
        if true {
            struct_ser.serialize_field("col4", &self.col_4)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for TypeSaladNumericIntegerTypes {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "id",
            "col_2",
            "col2",
            "col_3",
            "col3",
            "col_4",
            "col4",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Id,
            Col2,
            Col3,
            Col4,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;

                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;

                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", &FIELDS)
                    }

                    #[allow(unused_variables)]
                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "id" => Ok(GeneratedField::Id),
                            "col2" | "col_2" => Ok(GeneratedField::Col2),
                            "col3" | "col_3" => Ok(GeneratedField::Col3),
                            "col4" | "col_4" => Ok(GeneratedField::Col4),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = TypeSaladNumericIntegerTypes;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct acme.user.v1.TypeSaladNumericIntegerTypes")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TypeSaladNumericIntegerTypes, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut id__ = None;
                let mut col_2__ = None;
                let mut col_3__ = None;
                let mut col_4__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Id => {
                            if id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("id"));
                            }
                            id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Col2 => {
                            if col_2__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col2"));
                            }
                            col_2__ = 
                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                            ;
                        }
                        GeneratedField::Col3 => {
                            if col_3__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col3"));
                            }
                            col_3__ = 
                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                            ;
                        }
                        GeneratedField::Col4 => {
                            if col_4__.is_some() {
                                return Err(serde::de::Error::duplicate_field("col4"));
                            }
                            col_4__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(TypeSaladNumericIntegerTypes {
                    id: id__.unwrap_or_default(),
                    col_2: col_2__.unwrap_or_default(),
                    col_3: col_3__.unwrap_or_default(),
                    col_4: col_4__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("acme.user.v1.TypeSaladNumericIntegerTypes", FIELDS, GeneratedVisitor)
    }
}
impl serde::Serialize for TypeSaladUuidTypes {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if true {
            len += 1;
        }
        let mut struct_ser = serializer.serialize_struct("acme.user.v1.TypeSaladUuidTypes", len)?;
        if true {
            struct_ser.serialize_field("id", &self.id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for TypeSaladUuidTypes {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "id",
        ];

        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Id,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;

                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;

                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", &FIELDS)
                    }

                    #[allow(unused_variables)]
                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "id" => Ok(GeneratedField::Id),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = TypeSaladUuidTypes;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("struct acme.user.v1.TypeSaladUuidTypes")
            }

            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TypeSaladUuidTypes, V::Error>
                where
                    V: serde::de::MapAccess<'de>,
            {
                let mut id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Id => {
                            if id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("id"));
                            }
                            id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(TypeSaladUuidTypes {
                    id: id__.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_struct("acme.user.v1.TypeSaladUuidTypes", FIELDS, GeneratedVisitor)
    }
}
