From ef9c1db8c68636a6b4d971823ada892032035e0d Mon Sep 17 00:00:00 2001 From: Bill Fraser Date: Thu, 20 Feb 2025 17:59:13 -0800 Subject: [PATCH] correct some inconsistent match bindings Testing out the Rust 2024 edition revealed some cases where the generated serialization code is inconsistent with its binding modes. We start as ref, switch to move (using deref operator), then back to ref (using ref). The 2024 edition doesn't let you do this, and we don't need to anyway (just stay in ref mode), so let's fix that. --- generator/rust.stoneg.py | 12 +- src/generated/types/account.rs | 6 +- src/generated/types/auth.rs | 18 +- src/generated/types/common.rs | 16 +- src/generated/types/contacts.rs | 4 +- src/generated/types/dbx_async.rs | 14 +- src/generated/types/file_properties.rs | 72 +- src/generated/types/file_requests.rs | 28 +- src/generated/types/files.rs | 376 ++--- src/generated/types/openid.rs | 6 +- src/generated/types/paper.rs | 48 +- src/generated/types/seen_state.rs | 2 +- src/generated/types/sharing.rs | 318 ++-- src/generated/types/team.rs | 492 +++--- src/generated/types/team_common.rs | 6 +- src/generated/types/team_log.rs | 2140 ++++++++++++------------ src/generated/types/team_policies.rs | 56 +- src/generated/types/users.rs | 30 +- src/generated/types/users_common.rs | 2 +- 19 files changed, 1823 insertions(+), 1823 deletions(-) diff --git a/generator/rust.stoneg.py b/generator/rust.stoneg.py index be7f98c..f669593 100644 --- a/generator/rust.stoneg.py +++ b/generator/rust.stoneg.py @@ -608,10 +608,10 @@ def _impl_serde_for_polymorphic_struct(self, struct: ir.Struct) -> None: with self._impl_serialize(type_name): self.emit('// polymorphic struct serializer') self.emit('use serde::ser::SerializeStruct;') - with self.block('match *self'): + with self.block('match self'): for subtype in struct.get_enumerated_subtypes(): variant_name = self.enum_variant_name(subtype) - with self.block(f'{type_name}::{variant_name}(ref x) =>'): + with self.block(f'{type_name}::{variant_name}(x) =>'): self.emit('let mut s = serializer.serialize_struct(' f'"{type_name}", {len(subtype.data_type.all_fields) + 1})?;') self.emit(f's.serialize_field(".tag", "{subtype.name}")?;') @@ -710,7 +710,7 @@ def _impl_serde_for_union(self, union: ir.Union) -> None: 'no defined variants"))') else: self.emit('use serde::ser::SerializeStruct;') - with self.block('match *self'): + with self.block('match self'): for field in union.all_fields: if field.catch_all: # Handle the 'Other' variant at the end. @@ -726,8 +726,8 @@ def _impl_serde_for_union(self, union: ir.Union) -> None: ultimate_type = ir.unwrap(field.data_type)[0] needs_x = not (isinstance(field.data_type, ir.Struct) and not field.data_type.all_fields) - ref_x = 'ref x' if needs_x else '_' - with self.block(f'{type_name}::{variant_name}({ref_x}) =>'): + inner = 'x' if needs_x else '_' + with self.block(f'{type_name}::{variant_name}({inner}) =>'): if self.is_enum_type(ultimate_type): # Inner type is a union or polymorphic struct; need to always # emit another nesting level. @@ -746,7 +746,7 @@ def _impl_serde_for_union(self, union: ir.Union) -> None: self.emit(f'let n = if x.is_some() {{ {num_fields + 1} }} else {{ 1 }};') self.emit(f'let mut s = serializer.serialize_struct("{union.name}", n)?;') self.emit(f's.serialize_field(".tag", "{field.name}")?;') - with self.block('if let Some(ref x) = x'): + with self.block('if let Some(x) = x'): if ir.is_primitive_type(ultimate_type): self.emit(f's.serialize_field("{field.name}", &x)?;') else: diff --git a/src/generated/types/account.rs b/src/generated/types/account.rs index 928166b..e656109 100644 --- a/src/generated/types/account.rs +++ b/src/generated/types/account.rs @@ -57,8 +57,8 @@ impl ::serde::ser::Serialize for PhotoSourceArg { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - PhotoSourceArg::Base64Data(ref x) => { + match self { + PhotoSourceArg::Base64Data(x) => { // primitive let mut s = serializer.serialize_struct("PhotoSourceArg", 2)?; s.serialize_field(".tag", "base64_data")?; @@ -220,7 +220,7 @@ impl ::serde::ser::Serialize for SetProfilePhotoError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SetProfilePhotoError::FileTypeError => { // unit let mut s = serializer.serialize_struct("SetProfilePhotoError", 1)?; diff --git a/src/generated/types/auth.rs b/src/generated/types/auth.rs index f417cc2..ab47f74 100644 --- a/src/generated/types/auth.rs +++ b/src/generated/types/auth.rs @@ -68,15 +68,15 @@ impl ::serde::ser::Serialize for AccessError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AccessError::InvalidAccountType(ref x) => { + match self { + AccessError::InvalidAccountType(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AccessError", 2)?; s.serialize_field(".tag", "invalid_account_type")?; s.serialize_field("invalid_account_type", x)?; s.end() } - AccessError::PaperAccessDenied(ref x) => { + AccessError::PaperAccessDenied(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AccessError", 2)?; s.serialize_field(".tag", "paper_access_denied")?; @@ -176,7 +176,7 @@ impl ::serde::ser::Serialize for AuthError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AuthError::InvalidAccessToken => { // unit let mut s = serializer.serialize_struct("AuthError", 1)?; @@ -207,7 +207,7 @@ impl ::serde::ser::Serialize for AuthError { s.serialize_field(".tag", "expired_access_token")?; s.end() } - AuthError::MissingScope(ref x) => { + AuthError::MissingScope(x) => { // struct let mut s = serializer.serialize_struct("AuthError", 2)?; s.serialize_field(".tag", "missing_scope")?; @@ -290,7 +290,7 @@ impl ::serde::ser::Serialize for InvalidAccountTypeError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { InvalidAccountTypeError::Endpoint => { // unit let mut s = serializer.serialize_struct("InvalidAccountTypeError", 1)?; @@ -368,7 +368,7 @@ impl ::serde::ser::Serialize for PaperAccessError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperAccessError::PaperDisabled => { // unit let mut s = serializer.serialize_struct("PaperAccessError", 1)?; @@ -558,7 +558,7 @@ impl ::serde::ser::Serialize for RateLimitReason { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RateLimitReason::TooManyRequests => { // unit let mut s = serializer.serialize_struct("RateLimitReason", 1)?; @@ -737,7 +737,7 @@ impl ::serde::ser::Serialize for TokenFromOAuth1Error { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TokenFromOAuth1Error::InvalidOauth1TokenInfo => { // unit let mut s = serializer.serialize_struct("TokenFromOAuth1Error", 1)?; diff --git a/src/generated/types/common.rs b/src/generated/types/common.rs index 676edf4..8003232 100644 --- a/src/generated/types/common.rs +++ b/src/generated/types/common.rs @@ -86,21 +86,21 @@ impl ::serde::ser::Serialize for PathRoot { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PathRoot::Home => { // unit let mut s = serializer.serialize_struct("PathRoot", 1)?; s.serialize_field(".tag", "home")?; s.end() } - PathRoot::Root(ref x) => { + PathRoot::Root(x) => { // primitive let mut s = serializer.serialize_struct("PathRoot", 2)?; s.serialize_field(".tag", "root")?; s.serialize_field("root", x)?; s.end() } - PathRoot::NamespaceId(ref x) => { + PathRoot::NamespaceId(x) => { // primitive let mut s = serializer.serialize_struct("PathRoot", 2)?; s.serialize_field(".tag", "namespace_id")?; @@ -166,8 +166,8 @@ impl ::serde::ser::Serialize for PathRootError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - PathRootError::InvalidRoot(ref x) => { + match self { + PathRootError::InvalidRoot(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("PathRootError", 2)?; s.serialize_field(".tag", "invalid_root")?; @@ -244,14 +244,14 @@ impl ::serde::ser::Serialize for RootInfo { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - RootInfo::Team(ref x) => { + match self { + RootInfo::Team(x) => { let mut s = serializer.serialize_struct("RootInfo", 4)?; s.serialize_field(".tag", "team")?; x.internal_serialize::(&mut s)?; s.end() } - RootInfo::User(ref x) => { + RootInfo::User(x) => { let mut s = serializer.serialize_struct("RootInfo", 3)?; s.serialize_field(".tag", "user")?; x.internal_serialize::(&mut s)?; diff --git a/src/generated/types/contacts.rs b/src/generated/types/contacts.rs index 262364e..919d61a 100644 --- a/src/generated/types/contacts.rs +++ b/src/generated/types/contacts.rs @@ -149,8 +149,8 @@ impl ::serde::ser::Serialize for DeleteManualContactsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - DeleteManualContactsError::ContactsNotFound(ref x) => { + match self { + DeleteManualContactsError::ContactsNotFound(x) => { // primitive let mut s = serializer.serialize_struct("DeleteManualContactsError", 2)?; s.serialize_field(".tag", "contacts_not_found")?; diff --git a/src/generated/types/dbx_async.rs b/src/generated/types/dbx_async.rs index 63cf1f3..0aa446b 100644 --- a/src/generated/types/dbx_async.rs +++ b/src/generated/types/dbx_async.rs @@ -61,8 +61,8 @@ impl ::serde::ser::Serialize for LaunchEmptyResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - LaunchEmptyResult::AsyncJobId(ref x) => { + match self { + LaunchEmptyResult::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("LaunchEmptyResult", 2)?; s.serialize_field(".tag", "async_job_id")?; @@ -136,8 +136,8 @@ impl ::serde::ser::Serialize for LaunchResultBase { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - LaunchResultBase::AsyncJobId(ref x) => { + match self { + LaunchResultBase::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("LaunchResultBase", 2)?; s.serialize_field(".tag", "async_job_id")?; @@ -285,7 +285,7 @@ impl ::serde::ser::Serialize for PollEmptyResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PollEmptyResult::InProgress => { // unit let mut s = serializer.serialize_struct("PollEmptyResult", 1)?; @@ -359,7 +359,7 @@ impl ::serde::ser::Serialize for PollError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PollError::InvalidAsyncJobId => { // unit let mut s = serializer.serialize_struct("PollError", 1)?; @@ -431,7 +431,7 @@ impl ::serde::ser::Serialize for PollResultBase { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PollResultBase::InProgress => { // unit let mut s = serializer.serialize_struct("PollResultBase", 1)?; diff --git a/src/generated/types/file_properties.rs b/src/generated/types/file_properties.rs index 89f1625..eacee26 100644 --- a/src/generated/types/file_properties.rs +++ b/src/generated/types/file_properties.rs @@ -231,8 +231,8 @@ impl ::serde::ser::Serialize for AddPropertiesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AddPropertiesError::TemplateNotFound(ref x) => { + match self { + AddPropertiesError::TemplateNotFound(x) => { // primitive let mut s = serializer.serialize_struct("AddPropertiesError", 2)?; s.serialize_field(".tag", "template_not_found")?; @@ -245,7 +245,7 @@ impl ::serde::ser::Serialize for AddPropertiesError { s.serialize_field(".tag", "restricted_content")?; s.end() } - AddPropertiesError::Path(ref x) => { + AddPropertiesError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AddPropertiesError", 2)?; s.serialize_field(".tag", "path")?; @@ -847,8 +847,8 @@ impl ::serde::ser::Serialize for InvalidPropertyGroupError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - InvalidPropertyGroupError::TemplateNotFound(ref x) => { + match self { + InvalidPropertyGroupError::TemplateNotFound(x) => { // primitive let mut s = serializer.serialize_struct("InvalidPropertyGroupError", 2)?; s.serialize_field(".tag", "template_not_found")?; @@ -861,7 +861,7 @@ impl ::serde::ser::Serialize for InvalidPropertyGroupError { s.serialize_field(".tag", "restricted_content")?; s.end() } - InvalidPropertyGroupError::Path(ref x) => { + InvalidPropertyGroupError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("InvalidPropertyGroupError", 2)?; s.serialize_field(".tag", "path")?; @@ -1070,7 +1070,7 @@ impl ::serde::ser::Serialize for LogicalOperator { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LogicalOperator::OrOperator => { // unit let mut s = serializer.serialize_struct("LogicalOperator", 1)?; @@ -1125,7 +1125,7 @@ impl ::serde::ser::Serialize for LookUpPropertiesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LookUpPropertiesError::PropertyGroupNotFound => { // unit let mut s = serializer.serialize_struct("LookUpPropertiesError", 1)?; @@ -1214,8 +1214,8 @@ impl ::serde::ser::Serialize for LookupError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - LookupError::MalformedPath(ref x) => { + match self { + LookupError::MalformedPath(x) => { // primitive let mut s = serializer.serialize_struct("LookupError", 2)?; s.serialize_field(".tag", "malformed_path")?; @@ -1337,8 +1337,8 @@ impl ::serde::ser::Serialize for ModifyTemplateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ModifyTemplateError::TemplateNotFound(ref x) => { + match self { + ModifyTemplateError::TemplateNotFound(x) => { // primitive let mut s = serializer.serialize_struct("ModifyTemplateError", 2)?; s.serialize_field(".tag", "template_not_found")?; @@ -1578,8 +1578,8 @@ impl ::serde::ser::Serialize for PropertiesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - PropertiesError::TemplateNotFound(ref x) => { + match self { + PropertiesError::TemplateNotFound(x) => { // primitive let mut s = serializer.serialize_struct("PropertiesError", 2)?; s.serialize_field(".tag", "template_not_found")?; @@ -1592,7 +1592,7 @@ impl ::serde::ser::Serialize for PropertiesError { s.serialize_field(".tag", "restricted_content")?; s.end() } - PropertiesError::Path(ref x) => { + PropertiesError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("PropertiesError", 2)?; s.serialize_field(".tag", "path")?; @@ -1889,7 +1889,7 @@ impl ::serde::ser::Serialize for PropertiesSearchContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PropertiesSearchContinueError::Reset => { // unit let mut s = serializer.serialize_struct("PropertiesSearchContinueError", 1)?; @@ -1958,8 +1958,8 @@ impl ::serde::ser::Serialize for PropertiesSearchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - PropertiesSearchError::PropertyGroupLookup(ref x) => { + match self { + PropertiesSearchError::PropertyGroupLookup(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("PropertiesSearchError", 2)?; s.serialize_field(".tag", "property_group_lookup")?; @@ -2173,8 +2173,8 @@ impl ::serde::ser::Serialize for PropertiesSearchMode { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - PropertiesSearchMode::FieldName(ref x) => { + match self { + PropertiesSearchMode::FieldName(x) => { // primitive let mut s = serializer.serialize_struct("PropertiesSearchMode", 2)?; s.serialize_field(".tag", "field_name")?; @@ -3053,7 +3053,7 @@ impl ::serde::ser::Serialize for PropertyType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PropertyType::String => { // unit let mut s = serializer.serialize_struct("PropertyType", 1)?; @@ -3246,8 +3246,8 @@ impl ::serde::ser::Serialize for RemovePropertiesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RemovePropertiesError::TemplateNotFound(ref x) => { + match self { + RemovePropertiesError::TemplateNotFound(x) => { // primitive let mut s = serializer.serialize_struct("RemovePropertiesError", 2)?; s.serialize_field(".tag", "template_not_found")?; @@ -3260,7 +3260,7 @@ impl ::serde::ser::Serialize for RemovePropertiesError { s.serialize_field(".tag", "restricted_content")?; s.end() } - RemovePropertiesError::Path(ref x) => { + RemovePropertiesError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemovePropertiesError", 2)?; s.serialize_field(".tag", "path")?; @@ -3273,7 +3273,7 @@ impl ::serde::ser::Serialize for RemovePropertiesError { s.serialize_field(".tag", "unsupported_folder")?; s.end() } - RemovePropertiesError::PropertyGroupLookup(ref x) => { + RemovePropertiesError::PropertyGroupLookup(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemovePropertiesError", 2)?; s.serialize_field(".tag", "property_group_lookup")?; @@ -3466,8 +3466,8 @@ impl ::serde::ser::Serialize for TemplateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TemplateError::TemplateNotFound(ref x) => { + match self { + TemplateError::TemplateNotFound(x) => { // primitive let mut s = serializer.serialize_struct("TemplateError", 2)?; s.serialize_field(".tag", "template_not_found")?; @@ -3552,8 +3552,8 @@ impl ::serde::ser::Serialize for TemplateFilter { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TemplateFilter::FilterSome(ref x) => { + match self { + TemplateFilter::FilterSome(x) => { // primitive let mut s = serializer.serialize_struct("TemplateFilter", 2)?; s.serialize_field(".tag", "filter_some")?; @@ -3630,8 +3630,8 @@ impl ::serde::ser::Serialize for TemplateFilterBase { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TemplateFilterBase::FilterSome(ref x) => { + match self { + TemplateFilterBase::FilterSome(x) => { // primitive let mut s = serializer.serialize_struct("TemplateFilterBase", 2)?; s.serialize_field(".tag", "filter_some")?; @@ -3690,7 +3690,7 @@ impl ::serde::ser::Serialize for TemplateOwnerType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TemplateOwnerType::User => { // unit let mut s = serializer.serialize_struct("TemplateOwnerType", 1)?; @@ -3899,8 +3899,8 @@ impl ::serde::ser::Serialize for UpdatePropertiesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UpdatePropertiesError::TemplateNotFound(ref x) => { + match self { + UpdatePropertiesError::TemplateNotFound(x) => { // primitive let mut s = serializer.serialize_struct("UpdatePropertiesError", 2)?; s.serialize_field(".tag", "template_not_found")?; @@ -3913,7 +3913,7 @@ impl ::serde::ser::Serialize for UpdatePropertiesError { s.serialize_field(".tag", "restricted_content")?; s.end() } - UpdatePropertiesError::Path(ref x) => { + UpdatePropertiesError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UpdatePropertiesError", 2)?; s.serialize_field(".tag", "path")?; @@ -3944,7 +3944,7 @@ impl ::serde::ser::Serialize for UpdatePropertiesError { s.serialize_field(".tag", "duplicate_property_groups")?; s.end() } - UpdatePropertiesError::PropertyGroupLookup(ref x) => { + UpdatePropertiesError::PropertyGroupLookup(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UpdatePropertiesError", 2)?; s.serialize_field(".tag", "property_group_lookup")?; diff --git a/src/generated/types/file_requests.rs b/src/generated/types/file_requests.rs index f121390..193f3d0 100644 --- a/src/generated/types/file_requests.rs +++ b/src/generated/types/file_requests.rs @@ -57,7 +57,7 @@ impl ::serde::ser::Serialize for CountFileRequestsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { CountFileRequestsError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("CountFileRequestsError", 1)?; @@ -431,7 +431,7 @@ impl ::serde::ser::Serialize for CreateFileRequestError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { CreateFileRequestError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?; @@ -597,7 +597,7 @@ impl ::serde::ser::Serialize for DeleteAllClosedFileRequestsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DeleteAllClosedFileRequestsError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsError", 1)?; @@ -937,7 +937,7 @@ impl ::serde::ser::Serialize for DeleteFileRequestError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DeleteFileRequestError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?; @@ -1528,7 +1528,7 @@ impl ::serde::ser::Serialize for FileRequestError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileRequestError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("FileRequestError", 1)?; @@ -1646,7 +1646,7 @@ impl ::serde::ser::Serialize for GeneralFileRequestsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GeneralFileRequestsError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("GeneralFileRequestsError", 1)?; @@ -1834,7 +1834,7 @@ impl ::serde::ser::Serialize for GetFileRequestError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GetFileRequestError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("GetFileRequestError", 1)?; @@ -1968,7 +1968,7 @@ impl ::serde::ser::Serialize for GracePeriod { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GracePeriod::OneDay => { // unit let mut s = serializer.serialize_struct("GracePeriod", 1)?; @@ -2233,7 +2233,7 @@ impl ::serde::ser::Serialize for ListFileRequestsContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListFileRequestsContinueError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("ListFileRequestsContinueError", 1)?; @@ -2317,7 +2317,7 @@ impl ::serde::ser::Serialize for ListFileRequestsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListFileRequestsError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("ListFileRequestsError", 1)?; @@ -2806,19 +2806,19 @@ impl ::serde::ser::Serialize for UpdateFileRequestDeadline { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UpdateFileRequestDeadline::NoUpdate => { // unit let mut s = serializer.serialize_struct("UpdateFileRequestDeadline", 1)?; s.serialize_field(".tag", "no_update")?; s.end() } - UpdateFileRequestDeadline::Update(ref x) => { + UpdateFileRequestDeadline::Update(x) => { // nullable (struct or primitive) let n = if x.is_some() { 4 } else { 1 }; let mut s = serializer.serialize_struct("UpdateFileRequestDeadline", n)?; s.serialize_field(".tag", "update")?; - if let Some(ref x) = x { + if let Some(x) = x { x.internal_serialize::(&mut s)?; } s.end() @@ -2900,7 +2900,7 @@ impl ::serde::ser::Serialize for UpdateFileRequestError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UpdateFileRequestError::DisabledForTeam => { // unit let mut s = serializer.serialize_struct("UpdateFileRequestError", 1)?; diff --git a/src/generated/types/files.rs b/src/generated/types/files.rs index 249c8e1..4c2e9dc 100644 --- a/src/generated/types/files.rs +++ b/src/generated/types/files.rs @@ -184,8 +184,8 @@ impl ::serde::ser::Serialize for AddTagError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AddTagError::Path(ref x) => { + match self { + AddTagError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AddTagError", 2)?; s.serialize_field(".tag", "path")?; @@ -496,15 +496,15 @@ impl ::serde::ser::Serialize for AlphaGetMetadataError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AlphaGetMetadataError::Path(ref x) => { + match self { + AlphaGetMetadataError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AlphaGetMetadataError", 2)?; s.serialize_field(".tag", "path")?; s.serialize_field("path", x)?; s.end() } - AlphaGetMetadataError::PropertiesError(ref x) => { + AlphaGetMetadataError::PropertiesError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AlphaGetMetadataError", 2)?; s.serialize_field(".tag", "properties_error")?; @@ -589,8 +589,8 @@ impl ::serde::ser::Serialize for BaseTagError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - BaseTagError::Path(ref x) => { + match self { + BaseTagError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("BaseTagError", 2)?; s.serialize_field(".tag", "path")?; @@ -1339,7 +1339,7 @@ impl ::serde::ser::Serialize for CreateFolderBatchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { CreateFolderBatchError::TooManyFiles => { // unit let mut s = serializer.serialize_struct("CreateFolderBatchError", 1)?; @@ -1420,21 +1420,21 @@ impl ::serde::ser::Serialize for CreateFolderBatchJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { CreateFolderBatchJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("CreateFolderBatchJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - CreateFolderBatchJobStatus::Complete(ref x) => { + CreateFolderBatchJobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("CreateFolderBatchJobStatus", 2)?; s.serialize_field(".tag", "complete")?; x.internal_serialize::(&mut s)?; s.end() } - CreateFolderBatchJobStatus::Failed(ref x) => { + CreateFolderBatchJobStatus::Failed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CreateFolderBatchJobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -1509,15 +1509,15 @@ impl ::serde::ser::Serialize for CreateFolderBatchLaunch { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - CreateFolderBatchLaunch::AsyncJobId(ref x) => { + match self { + CreateFolderBatchLaunch::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("CreateFolderBatchLaunch", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - CreateFolderBatchLaunch::Complete(ref x) => { + CreateFolderBatchLaunch::Complete(x) => { // struct let mut s = serializer.serialize_struct("CreateFolderBatchLaunch", 2)?; s.serialize_field(".tag", "complete")?; @@ -1681,15 +1681,15 @@ impl ::serde::ser::Serialize for CreateFolderBatchResultEntry { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - CreateFolderBatchResultEntry::Success(ref x) => { + match self { + CreateFolderBatchResultEntry::Success(x) => { // struct let mut s = serializer.serialize_struct("CreateFolderBatchResultEntry", 2)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - CreateFolderBatchResultEntry::Failure(ref x) => { + CreateFolderBatchResultEntry::Failure(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CreateFolderBatchResultEntry", 2)?; s.serialize_field(".tag", "failure")?; @@ -1748,8 +1748,8 @@ impl ::serde::ser::Serialize for CreateFolderEntryError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - CreateFolderEntryError::Path(ref x) => { + match self { + CreateFolderEntryError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CreateFolderEntryError", 2)?; s.serialize_field(".tag", "path")?; @@ -1913,8 +1913,8 @@ impl ::serde::ser::Serialize for CreateFolderError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - CreateFolderError::Path(ref x) => { + match self { + CreateFolderError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CreateFolderError", 2)?; s.serialize_field(".tag", "path")?; @@ -2284,7 +2284,7 @@ impl ::serde::ser::Serialize for DeleteBatchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DeleteBatchError::TooManyWriteOperations => { // unit let mut s = serializer.serialize_struct("DeleteBatchError", 1)?; @@ -2362,21 +2362,21 @@ impl ::serde::ser::Serialize for DeleteBatchJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DeleteBatchJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("DeleteBatchJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - DeleteBatchJobStatus::Complete(ref x) => { + DeleteBatchJobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("DeleteBatchJobStatus", 2)?; s.serialize_field(".tag", "complete")?; x.internal_serialize::(&mut s)?; s.end() } - DeleteBatchJobStatus::Failed(ref x) => { + DeleteBatchJobStatus::Failed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("DeleteBatchJobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -2451,15 +2451,15 @@ impl ::serde::ser::Serialize for DeleteBatchLaunch { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - DeleteBatchLaunch::AsyncJobId(ref x) => { + match self { + DeleteBatchLaunch::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("DeleteBatchLaunch", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - DeleteBatchLaunch::Complete(ref x) => { + DeleteBatchLaunch::Complete(x) => { // struct let mut s = serializer.serialize_struct("DeleteBatchLaunch", 2)?; s.serialize_field(".tag", "complete")?; @@ -2714,15 +2714,15 @@ impl ::serde::ser::Serialize for DeleteBatchResultEntry { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - DeleteBatchResultEntry::Success(ref x) => { + match self { + DeleteBatchResultEntry::Success(x) => { // struct let mut s = serializer.serialize_struct("DeleteBatchResultEntry", 2)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - DeleteBatchResultEntry::Failure(ref x) => { + DeleteBatchResultEntry::Failure(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("DeleteBatchResultEntry", 2)?; s.serialize_field(".tag", "failure")?; @@ -2798,15 +2798,15 @@ impl ::serde::ser::Serialize for DeleteError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - DeleteError::PathLookup(ref x) => { + match self { + DeleteError::PathLookup(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("DeleteError", 2)?; s.serialize_field(".tag", "path_lookup")?; s.serialize_field("path_lookup", x)?; s.end() } - DeleteError::PathWrite(ref x) => { + DeleteError::PathWrite(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("DeleteError", 2)?; s.serialize_field(".tag", "path_write")?; @@ -3406,8 +3406,8 @@ impl ::serde::ser::Serialize for DownloadError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - DownloadError::Path(ref x) => { + match self { + DownloadError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("DownloadError", 2)?; s.serialize_field(".tag", "path")?; @@ -3590,8 +3590,8 @@ impl ::serde::ser::Serialize for DownloadZipError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - DownloadZipError::Path(ref x) => { + match self { + DownloadZipError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("DownloadZipError", 2)?; s.serialize_field(".tag", "path")?; @@ -3899,8 +3899,8 @@ impl ::serde::ser::Serialize for ExportError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ExportError::Path(ref x) => { + match self { + ExportError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ExportError", 2)?; s.serialize_field(".tag", "path")?; @@ -4382,7 +4382,7 @@ impl ::serde::ser::Serialize for FileCategory { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileCategory::Image => { // unit let mut s = serializer.serialize_struct("FileCategory", 1)?; @@ -4586,14 +4586,14 @@ impl ::serde::ser::Serialize for FileLockContent { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileLockContent::Unlocked => { // unit let mut s = serializer.serialize_struct("FileLockContent", 1)?; s.serialize_field(".tag", "unlocked")?; s.end() } - FileLockContent::SingleUser(ref x) => { + FileLockContent::SingleUser(x) => { // struct let mut s = serializer.serialize_struct("FileLockContent", 4)?; s.serialize_field(".tag", "single_user")?; @@ -5429,7 +5429,7 @@ impl ::serde::ser::Serialize for FileStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileStatus::Active => { // unit let mut s = serializer.serialize_struct("FileStatus", 1)?; @@ -6038,8 +6038,8 @@ impl ::serde::ser::Serialize for GetCopyReferenceError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GetCopyReferenceError::Path(ref x) => { + match self { + GetCopyReferenceError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("GetCopyReferenceError", 2)?; s.serialize_field(".tag", "path")?; @@ -6411,8 +6411,8 @@ impl ::serde::ser::Serialize for GetMetadataError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GetMetadataError::Path(ref x) => { + match self { + GetMetadataError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("GetMetadataError", 2)?; s.serialize_field(".tag", "path")?; @@ -6776,8 +6776,8 @@ impl ::serde::ser::Serialize for GetTemporaryLinkError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GetTemporaryLinkError::Path(ref x) => { + match self { + GetTemporaryLinkError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("GetTemporaryLinkError", 2)?; s.serialize_field(".tag", "path")?; @@ -7268,7 +7268,7 @@ impl ::serde::ser::Serialize for GetThumbnailBatchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GetThumbnailBatchError::TooManyFiles => { // unit let mut s = serializer.serialize_struct("GetThumbnailBatchError", 1)?; @@ -7538,15 +7538,15 @@ impl ::serde::ser::Serialize for GetThumbnailBatchResultEntry { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GetThumbnailBatchResultEntry::Success(ref x) => { + match self { + GetThumbnailBatchResultEntry::Success(x) => { // struct let mut s = serializer.serialize_struct("GetThumbnailBatchResultEntry", 3)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - GetThumbnailBatchResultEntry::Failure(ref x) => { + GetThumbnailBatchResultEntry::Failure(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("GetThumbnailBatchResultEntry", 2)?; s.serialize_field(".tag", "failure")?; @@ -7819,7 +7819,7 @@ impl ::serde::ser::Serialize for ImportFormat { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ImportFormat::Html => { // unit let mut s = serializer.serialize_struct("ImportFormat", 1)?; @@ -8271,8 +8271,8 @@ impl ::serde::ser::Serialize for ListFolderContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListFolderContinueError::Path(ref x) => { + match self { + ListFolderContinueError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFolderContinueError", 2)?; s.serialize_field(".tag", "path")?; @@ -8365,15 +8365,15 @@ impl ::serde::ser::Serialize for ListFolderError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListFolderError::Path(ref x) => { + match self { + ListFolderError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFolderError", 2)?; s.serialize_field(".tag", "path")?; s.serialize_field("path", x)?; s.end() } - ListFolderError::TemplateError(ref x) => { + ListFolderError::TemplateError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFolderError", 2)?; s.serialize_field(".tag", "template_error")?; @@ -8656,7 +8656,7 @@ impl ::serde::ser::Serialize for ListFolderLongpollError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListFolderLongpollError::Reset => { // unit let mut s = serializer.serialize_struct("ListFolderLongpollError", 1)?; @@ -9088,8 +9088,8 @@ impl ::serde::ser::Serialize for ListRevisionsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListRevisionsError::Path(ref x) => { + match self { + ListRevisionsError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListRevisionsError", 2)?; s.serialize_field(".tag", "path")?; @@ -9168,7 +9168,7 @@ impl ::serde::ser::Serialize for ListRevisionsMode { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListRevisionsMode::Path => { // unit let mut s = serializer.serialize_struct("ListRevisionsMode", 1)?; @@ -9760,8 +9760,8 @@ impl ::serde::ser::Serialize for LockFileError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - LockFileError::PathLookup(ref x) => { + match self { + LockFileError::PathLookup(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("LockFileError", 2)?; s.serialize_field(".tag", "path_lookup")?; @@ -9798,7 +9798,7 @@ impl ::serde::ser::Serialize for LockFileError { s.serialize_field(".tag", "file_not_shared")?; s.end() } - LockFileError::LockConflict(ref x) => { + LockFileError::LockConflict(x) => { // struct let mut s = serializer.serialize_struct("LockFileError", 2)?; s.serialize_field(".tag", "lock_conflict")?; @@ -9991,15 +9991,15 @@ impl ::serde::ser::Serialize for LockFileResultEntry { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - LockFileResultEntry::Success(ref x) => { + match self { + LockFileResultEntry::Success(x) => { // struct let mut s = serializer.serialize_struct("LockFileResultEntry", 3)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - LockFileResultEntry::Failure(ref x) => { + LockFileResultEntry::Failure(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("LockFileResultEntry", 2)?; s.serialize_field(".tag", "failure")?; @@ -10086,13 +10086,13 @@ impl ::serde::ser::Serialize for LookupError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - LookupError::MalformedPath(ref x) => { + match self { + LookupError::MalformedPath(x) => { // nullable (struct or primitive) let n = if x.is_some() { 2 } else { 1 }; let mut s = serializer.serialize_struct("LookupError", n)?; s.serialize_field(".tag", "malformed_path")?; - if let Some(ref x) = x { + if let Some(x) = x { s.serialize_field("malformed_path", &x)?; } s.end() @@ -10204,14 +10204,14 @@ impl ::serde::ser::Serialize for MediaInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MediaInfo::Pending => { // unit let mut s = serializer.serialize_struct("MediaInfo", 1)?; s.serialize_field(".tag", "pending")?; s.end() } - MediaInfo::Metadata(ref x) => { + MediaInfo::Metadata(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("MediaInfo", 2)?; s.serialize_field(".tag", "metadata")?; @@ -10261,14 +10261,14 @@ impl ::serde::ser::Serialize for MediaMetadata { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - MediaMetadata::Photo(ref x) => { + match self { + MediaMetadata::Photo(x) => { let mut s = serializer.serialize_struct("MediaMetadata", 4)?; s.serialize_field(".tag", "photo")?; x.internal_serialize::(&mut s)?; s.end() } - MediaMetadata::Video(ref x) => { + MediaMetadata::Video(x) => { let mut s = serializer.serialize_struct("MediaMetadata", 5)?; s.serialize_field(".tag", "video")?; x.internal_serialize::(&mut s)?; @@ -10320,20 +10320,20 @@ impl ::serde::ser::Serialize for Metadata { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - Metadata::File(ref x) => { + match self { + Metadata::File(x) => { let mut s = serializer.serialize_struct("Metadata", 20)?; s.serialize_field(".tag", "file")?; x.internal_serialize::(&mut s)?; s.end() } - Metadata::Folder(ref x) => { + Metadata::Folder(x) => { let mut s = serializer.serialize_struct("Metadata", 10)?; s.serialize_field(".tag", "folder")?; x.internal_serialize::(&mut s)?; s.end() } - Metadata::Deleted(ref x) => { + Metadata::Deleted(x) => { let mut s = serializer.serialize_struct("Metadata", 6)?; s.serialize_field(".tag", "deleted")?; x.internal_serialize::(&mut s)?; @@ -10392,8 +10392,8 @@ impl ::serde::ser::Serialize for MetadataV2 { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MetadataV2::Metadata(ref x) => { + match self { + MetadataV2::Metadata(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("MetadataV2", 2)?; s.serialize_field(".tag", "metadata")?; @@ -10736,7 +10736,7 @@ impl ::serde::ser::Serialize for MoveIntoFamilyError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MoveIntoFamilyError::IsSharedFolder => { // unit let mut s = serializer.serialize_struct("MoveIntoFamilyError", 1)?; @@ -10803,7 +10803,7 @@ impl ::serde::ser::Serialize for MoveIntoVaultError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MoveIntoVaultError::IsSharedFolder => { // unit let mut s = serializer.serialize_struct("MoveIntoVaultError", 1)?; @@ -10883,7 +10883,7 @@ impl ::serde::ser::Serialize for PaperContentError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperContentError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("PaperContentError", 1)?; @@ -11105,7 +11105,7 @@ impl ::serde::ser::Serialize for PaperCreateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperCreateError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("PaperCreateError", 1)?; @@ -11376,7 +11376,7 @@ impl ::serde::ser::Serialize for PaperDocUpdatePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDocUpdatePolicy::Update => { // unit let mut s = serializer.serialize_struct("PaperDocUpdatePolicy", 1)?; @@ -11626,7 +11626,7 @@ impl ::serde::ser::Serialize for PaperUpdateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperUpdateError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("PaperUpdateError", 1)?; @@ -11651,7 +11651,7 @@ impl ::serde::ser::Serialize for PaperUpdateError { s.serialize_field(".tag", "image_size_exceeded")?; s.end() } - PaperUpdateError::Path(ref x) => { + PaperUpdateError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("PaperUpdateError", 2)?; s.serialize_field(".tag", "path")?; @@ -11860,15 +11860,15 @@ impl ::serde::ser::Serialize for PathOrLink { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - PathOrLink::Path(ref x) => { + match self { + PathOrLink::Path(x) => { // primitive let mut s = serializer.serialize_struct("PathOrLink", 2)?; s.serialize_field(".tag", "path")?; s.serialize_field("path", x)?; s.end() } - PathOrLink::Link(ref x) => { + PathOrLink::Link(x) => { // struct let mut s = serializer.serialize_struct("PathOrLink", 4)?; s.serialize_field(".tag", "link")?; @@ -12277,8 +12277,8 @@ impl ::serde::ser::Serialize for PreviewError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - PreviewError::Path(ref x) => { + match self { + PreviewError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("PreviewError", 2)?; s.serialize_field(".tag", "path")?; @@ -13008,22 +13008,22 @@ impl ::serde::ser::Serialize for RelocationBatchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RelocationBatchError::FromLookup(ref x) => { + match self { + RelocationBatchError::FromLookup(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchError", 2)?; s.serialize_field(".tag", "from_lookup")?; s.serialize_field("from_lookup", x)?; s.end() } - RelocationBatchError::FromWrite(ref x) => { + RelocationBatchError::FromWrite(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchError", 2)?; s.serialize_field(".tag", "from_write")?; s.serialize_field("from_write", x)?; s.end() } - RelocationBatchError::To(ref x) => { + RelocationBatchError::To(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchError", 2)?; s.serialize_field(".tag", "to")?; @@ -13084,14 +13084,14 @@ impl ::serde::ser::Serialize for RelocationBatchError { s.serialize_field(".tag", "cant_move_shared_folder")?; s.end() } - RelocationBatchError::CantMoveIntoVault(ref x) => { + RelocationBatchError::CantMoveIntoVault(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchError", 2)?; s.serialize_field(".tag", "cant_move_into_vault")?; s.serialize_field("cant_move_into_vault", x)?; s.end() } - RelocationBatchError::CantMoveIntoFamily(ref x) => { + RelocationBatchError::CantMoveIntoFamily(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchError", 2)?; s.serialize_field(".tag", "cant_move_into_family")?; @@ -13223,8 +13223,8 @@ impl ::serde::ser::Serialize for RelocationBatchErrorEntry { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RelocationBatchErrorEntry::RelocationError(ref x) => { + match self { + RelocationBatchErrorEntry::RelocationError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchErrorEntry", 2)?; s.serialize_field(".tag", "relocation_error")?; @@ -13300,21 +13300,21 @@ impl ::serde::ser::Serialize for RelocationBatchJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RelocationBatchJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("RelocationBatchJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - RelocationBatchJobStatus::Complete(ref x) => { + RelocationBatchJobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("RelocationBatchJobStatus", 2)?; s.serialize_field(".tag", "complete")?; x.internal_serialize::(&mut s)?; s.end() } - RelocationBatchJobStatus::Failed(ref x) => { + RelocationBatchJobStatus::Failed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchJobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -13389,15 +13389,15 @@ impl ::serde::ser::Serialize for RelocationBatchLaunch { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RelocationBatchLaunch::AsyncJobId(ref x) => { + match self { + RelocationBatchLaunch::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("RelocationBatchLaunch", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - RelocationBatchLaunch::Complete(ref x) => { + RelocationBatchLaunch::Complete(x) => { // struct let mut s = serializer.serialize_struct("RelocationBatchLaunch", 2)?; s.serialize_field(".tag", "complete")?; @@ -13661,15 +13661,15 @@ impl ::serde::ser::Serialize for RelocationBatchResultEntry { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RelocationBatchResultEntry::Success(ref x) => { + match self { + RelocationBatchResultEntry::Success(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchResultEntry", 2)?; s.serialize_field(".tag", "success")?; s.serialize_field("success", x)?; s.end() } - RelocationBatchResultEntry::Failure(ref x) => { + RelocationBatchResultEntry::Failure(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationBatchResultEntry", 2)?; s.serialize_field(".tag", "failure")?; @@ -13726,14 +13726,14 @@ impl ::serde::ser::Serialize for RelocationBatchV2JobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RelocationBatchV2JobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("RelocationBatchV2JobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - RelocationBatchV2JobStatus::Complete(ref x) => { + RelocationBatchV2JobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("RelocationBatchV2JobStatus", 2)?; s.serialize_field(".tag", "complete")?; @@ -13803,15 +13803,15 @@ impl ::serde::ser::Serialize for RelocationBatchV2Launch { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RelocationBatchV2Launch::AsyncJobId(ref x) => { + match self { + RelocationBatchV2Launch::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("RelocationBatchV2Launch", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - RelocationBatchV2Launch::Complete(ref x) => { + RelocationBatchV2Launch::Complete(x) => { // struct let mut s = serializer.serialize_struct("RelocationBatchV2Launch", 2)?; s.serialize_field(".tag", "complete")?; @@ -14054,22 +14054,22 @@ impl ::serde::ser::Serialize for RelocationError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RelocationError::FromLookup(ref x) => { + match self { + RelocationError::FromLookup(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationError", 2)?; s.serialize_field(".tag", "from_lookup")?; s.serialize_field("from_lookup", x)?; s.end() } - RelocationError::FromWrite(ref x) => { + RelocationError::FromWrite(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationError", 2)?; s.serialize_field(".tag", "from_write")?; s.serialize_field("from_write", x)?; s.end() } - RelocationError::To(ref x) => { + RelocationError::To(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationError", 2)?; s.serialize_field(".tag", "to")?; @@ -14130,14 +14130,14 @@ impl ::serde::ser::Serialize for RelocationError { s.serialize_field(".tag", "cant_move_shared_folder")?; s.end() } - RelocationError::CantMoveIntoVault(ref x) => { + RelocationError::CantMoveIntoVault(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationError", 2)?; s.serialize_field(".tag", "cant_move_into_vault")?; s.serialize_field("cant_move_into_vault", x)?; s.end() } - RelocationError::CantMoveIntoFamily(ref x) => { + RelocationError::CantMoveIntoFamily(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelocationError", 2)?; s.serialize_field(".tag", "cant_move_into_family")?; @@ -14539,8 +14539,8 @@ impl ::serde::ser::Serialize for RemoveTagError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RemoveTagError::Path(ref x) => { + match self { + RemoveTagError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemoveTagError", 2)?; s.serialize_field(".tag", "path")?; @@ -14757,15 +14757,15 @@ impl ::serde::ser::Serialize for RestoreError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RestoreError::PathLookup(ref x) => { + match self { + RestoreError::PathLookup(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RestoreError", 2)?; s.serialize_field(".tag", "path_lookup")?; s.serialize_field("path_lookup", x)?; s.end() } - RestoreError::PathWrite(ref x) => { + RestoreError::PathWrite(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RestoreError", 2)?; s.serialize_field(".tag", "path_write")?; @@ -14980,8 +14980,8 @@ impl ::serde::ser::Serialize for SaveCopyReferenceError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SaveCopyReferenceError::Path(ref x) => { + match self { + SaveCopyReferenceError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("SaveCopyReferenceError", 2)?; s.serialize_field(".tag", "path")?; @@ -15295,8 +15295,8 @@ impl ::serde::ser::Serialize for SaveUrlError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SaveUrlError::Path(ref x) => { + match self { + SaveUrlError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("SaveUrlError", 2)?; s.serialize_field(".tag", "path")?; @@ -15398,21 +15398,21 @@ impl ::serde::ser::Serialize for SaveUrlJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SaveUrlJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("SaveUrlJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - SaveUrlJobStatus::Complete(ref x) => { + SaveUrlJobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("SaveUrlJobStatus", 20)?; s.serialize_field(".tag", "complete")?; x.internal_serialize::(&mut s)?; s.end() } - SaveUrlJobStatus::Failed(ref x) => { + SaveUrlJobStatus::Failed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("SaveUrlJobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -15480,15 +15480,15 @@ impl ::serde::ser::Serialize for SaveUrlResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SaveUrlResult::AsyncJobId(ref x) => { + match self { + SaveUrlResult::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("SaveUrlResult", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - SaveUrlResult::Complete(ref x) => { + SaveUrlResult::Complete(x) => { // struct let mut s = serializer.serialize_struct("SaveUrlResult", 20)?; s.serialize_field(".tag", "complete")?; @@ -15735,20 +15735,20 @@ impl ::serde::ser::Serialize for SearchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SearchError::Path(ref x) => { + match self { + SearchError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("SearchError", 2)?; s.serialize_field(".tag", "path")?; s.serialize_field("path", x)?; s.end() } - SearchError::InvalidArgument(ref x) => { + SearchError::InvalidArgument(x) => { // nullable (struct or primitive) let n = if x.is_some() { 2 } else { 1 }; let mut s = serializer.serialize_struct("SearchError", n)?; s.serialize_field(".tag", "invalid_argument")?; - if let Some(ref x) = x { + if let Some(x) = x { s.serialize_field("invalid_argument", &x)?; } s.end() @@ -16017,7 +16017,7 @@ impl ::serde::ser::Serialize for SearchMatchType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SearchMatchType::Filename => { // unit let mut s = serializer.serialize_struct("SearchMatchType", 1)?; @@ -16096,7 +16096,7 @@ impl ::serde::ser::Serialize for SearchMatchTypeV2 { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SearchMatchTypeV2::Filename => { // unit let mut s = serializer.serialize_struct("SearchMatchTypeV2", 1)?; @@ -16303,7 +16303,7 @@ impl ::serde::ser::Serialize for SearchMode { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SearchMode::Filename => { // unit let mut s = serializer.serialize_struct("SearchMode", 1)?; @@ -16603,7 +16603,7 @@ impl ::serde::ser::Serialize for SearchOrderBy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SearchOrderBy::Relevance => { // unit let mut s = serializer.serialize_struct("SearchOrderBy", 1)?; @@ -17720,7 +17720,7 @@ impl ::serde::ser::Serialize for SyncSetting { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SyncSetting::Default => { // unit let mut s = serializer.serialize_struct("SyncSetting", 1)?; @@ -17793,7 +17793,7 @@ impl ::serde::ser::Serialize for SyncSettingArg { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SyncSettingArg::Default => { // unit let mut s = serializer.serialize_struct("SyncSettingArg", 1)?; @@ -17867,8 +17867,8 @@ impl ::serde::ser::Serialize for SyncSettingsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SyncSettingsError::Path(ref x) => { + match self { + SyncSettingsError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("SyncSettingsError", 2)?; s.serialize_field(".tag", "path")?; @@ -17956,8 +17956,8 @@ impl ::serde::ser::Serialize for Tag { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - Tag::UserGeneratedTag(ref x) => { + match self { + Tag::UserGeneratedTag(x) => { // struct let mut s = serializer.serialize_struct("Tag", 2)?; s.serialize_field(".tag", "user_generated_tag")?; @@ -18177,8 +18177,8 @@ impl ::serde::ser::Serialize for ThumbnailError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ThumbnailError::Path(ref x) => { + match self { + ThumbnailError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ThumbnailError", 2)?; s.serialize_field(".tag", "path")?; @@ -18267,7 +18267,7 @@ impl ::serde::ser::Serialize for ThumbnailFormat { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ThumbnailFormat::Jpeg => { // unit let mut s = serializer.serialize_struct("ThumbnailFormat", 1)?; @@ -18330,7 +18330,7 @@ impl ::serde::ser::Serialize for ThumbnailMode { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ThumbnailMode::Strict => { // unit let mut s = serializer.serialize_struct("ThumbnailMode", 1)?; @@ -18423,7 +18423,7 @@ impl ::serde::ser::Serialize for ThumbnailSize { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ThumbnailSize::W32h32 => { // unit let mut s = serializer.serialize_struct("ThumbnailSize", 1)?; @@ -18704,8 +18704,8 @@ impl ::serde::ser::Serialize for ThumbnailV2Error { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ThumbnailV2Error::Path(ref x) => { + match self { + ThumbnailV2Error::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ThumbnailV2Error", 2)?; s.serialize_field(".tag", "path")?; @@ -19274,15 +19274,15 @@ impl ::serde::ser::Serialize for UploadError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UploadError::Path(ref x) => { + match self { + UploadError::Path(x) => { // struct let mut s = serializer.serialize_struct("UploadError", 3)?; s.serialize_field(".tag", "path")?; x.internal_serialize::(&mut s)?; s.end() } - UploadError::PropertiesError(ref x) => { + UploadError::PropertiesError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UploadError", 2)?; s.serialize_field(".tag", "properties_error")?; @@ -19543,14 +19543,14 @@ impl ::serde::ser::Serialize for UploadSessionAppendError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UploadSessionAppendError::NotFound => { // unit let mut s = serializer.serialize_struct("UploadSessionAppendError", 1)?; s.serialize_field(".tag", "not_found")?; s.end() } - UploadSessionAppendError::IncorrectOffset(ref x) => { + UploadSessionAppendError::IncorrectOffset(x) => { // struct let mut s = serializer.serialize_struct("UploadSessionAppendError", 2)?; s.serialize_field(".tag", "incorrect_offset")?; @@ -20006,14 +20006,14 @@ impl ::serde::ser::Serialize for UploadSessionFinishBatchJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UploadSessionFinishBatchJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("UploadSessionFinishBatchJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - UploadSessionFinishBatchJobStatus::Complete(ref x) => { + UploadSessionFinishBatchJobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("UploadSessionFinishBatchJobStatus", 2)?; s.serialize_field(".tag", "complete")?; @@ -20087,15 +20087,15 @@ impl ::serde::ser::Serialize for UploadSessionFinishBatchLaunch { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UploadSessionFinishBatchLaunch::AsyncJobId(ref x) => { + match self { + UploadSessionFinishBatchLaunch::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("UploadSessionFinishBatchLaunch", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - UploadSessionFinishBatchLaunch::Complete(ref x) => { + UploadSessionFinishBatchLaunch::Complete(x) => { // struct let mut s = serializer.serialize_struct("UploadSessionFinishBatchLaunch", 2)?; s.serialize_field(".tag", "complete")?; @@ -20254,15 +20254,15 @@ impl ::serde::ser::Serialize for UploadSessionFinishBatchResultEntry { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UploadSessionFinishBatchResultEntry::Success(ref x) => { + match self { + UploadSessionFinishBatchResultEntry::Success(x) => { // struct let mut s = serializer.serialize_struct("UploadSessionFinishBatchResultEntry", 20)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - UploadSessionFinishBatchResultEntry::Failure(ref x) => { + UploadSessionFinishBatchResultEntry::Failure(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UploadSessionFinishBatchResultEntry", 2)?; s.serialize_field(".tag", "failure")?; @@ -20374,22 +20374,22 @@ impl ::serde::ser::Serialize for UploadSessionFinishError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UploadSessionFinishError::LookupFailed(ref x) => { + match self { + UploadSessionFinishError::LookupFailed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UploadSessionFinishError", 2)?; s.serialize_field(".tag", "lookup_failed")?; s.serialize_field("lookup_failed", x)?; s.end() } - UploadSessionFinishError::Path(ref x) => { + UploadSessionFinishError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UploadSessionFinishError", 2)?; s.serialize_field(".tag", "path")?; s.serialize_field("path", x)?; s.end() } - UploadSessionFinishError::PropertiesError(ref x) => { + UploadSessionFinishError::PropertiesError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UploadSessionFinishError", 2)?; s.serialize_field(".tag", "properties_error")?; @@ -20548,14 +20548,14 @@ impl ::serde::ser::Serialize for UploadSessionLookupError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UploadSessionLookupError::NotFound => { // unit let mut s = serializer.serialize_struct("UploadSessionLookupError", 1)?; s.serialize_field(".tag", "not_found")?; s.end() } - UploadSessionLookupError::IncorrectOffset(ref x) => { + UploadSessionLookupError::IncorrectOffset(x) => { // struct let mut s = serializer.serialize_struct("UploadSessionLookupError", 2)?; s.serialize_field(".tag", "incorrect_offset")?; @@ -21098,7 +21098,7 @@ impl ::serde::ser::Serialize for UploadSessionStartError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UploadSessionStartError::ConcurrentSessionDataNotAllowed => { // unit let mut s = serializer.serialize_struct("UploadSessionStartError", 1)?; @@ -21283,7 +21283,7 @@ impl ::serde::ser::Serialize for UploadSessionType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UploadSessionType::Sequential => { // unit let mut s = serializer.serialize_struct("UploadSessionType", 1)?; @@ -21693,7 +21693,7 @@ impl ::serde::ser::Serialize for WriteConflictError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { WriteConflictError::File => { // unit let mut s = serializer.serialize_struct("WriteConflictError", 1)?; @@ -21816,18 +21816,18 @@ impl ::serde::ser::Serialize for WriteError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - WriteError::MalformedPath(ref x) => { + match self { + WriteError::MalformedPath(x) => { // nullable (struct or primitive) let n = if x.is_some() { 2 } else { 1 }; let mut s = serializer.serialize_struct("WriteError", n)?; s.serialize_field(".tag", "malformed_path")?; - if let Some(ref x) = x { + if let Some(x) = x { s.serialize_field("malformed_path", &x)?; } s.end() } - WriteError::Conflict(ref x) => { + WriteError::Conflict(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("WriteError", 2)?; s.serialize_field(".tag", "conflict")?; @@ -21968,7 +21968,7 @@ impl ::serde::ser::Serialize for WriteMode { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { WriteMode::Add => { // unit let mut s = serializer.serialize_struct("WriteMode", 1)?; @@ -21981,7 +21981,7 @@ impl ::serde::ser::Serialize for WriteMode { s.serialize_field(".tag", "overwrite")?; s.end() } - WriteMode::Update(ref x) => { + WriteMode::Update(x) => { // primitive let mut s = serializer.serialize_struct("WriteMode", 2)?; s.serialize_field(".tag", "update")?; diff --git a/src/generated/types/openid.rs b/src/generated/types/openid.rs index ad80015..1c01725 100644 --- a/src/generated/types/openid.rs +++ b/src/generated/types/openid.rs @@ -51,7 +51,7 @@ impl ::serde::ser::Serialize for OpenIdError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { OpenIdError::IncorrectOpenidScopes => { // unit let mut s = serializer.serialize_struct("OpenIdError", 1)?; @@ -167,8 +167,8 @@ impl ::serde::ser::Serialize for UserInfoError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UserInfoError::OpenidError(ref x) => { + match self { + UserInfoError::OpenidError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UserInfoError", 2)?; s.serialize_field(".tag", "openid_error")?; diff --git a/src/generated/types/paper.rs b/src/generated/types/paper.rs index 31b6ad5..b2efcc5 100644 --- a/src/generated/types/paper.rs +++ b/src/generated/types/paper.rs @@ -456,7 +456,7 @@ impl ::serde::ser::Serialize for AddPaperDocUserResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AddPaperDocUserResult::Success => { // unit let mut s = serializer.serialize_struct("AddPaperDocUserResult", 1)?; @@ -674,7 +674,7 @@ impl ::serde::ser::Serialize for DocLookupError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DocLookupError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("DocLookupError", 1)?; @@ -764,7 +764,7 @@ impl ::serde::ser::Serialize for DocSubscriptionLevel { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DocSubscriptionLevel::Default => { // unit let mut s = serializer.serialize_struct("DocSubscriptionLevel", 1)?; @@ -841,7 +841,7 @@ impl ::serde::ser::Serialize for ExportFormat { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExportFormat::Html => { // unit let mut s = serializer.serialize_struct("ExportFormat", 1)?; @@ -1008,7 +1008,7 @@ impl ::serde::ser::Serialize for FolderSharingPolicyType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FolderSharingPolicyType::Team => { // unit let mut s = serializer.serialize_struct("FolderSharingPolicyType", 1)?; @@ -1076,7 +1076,7 @@ impl ::serde::ser::Serialize for FolderSubscriptionLevel { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FolderSubscriptionLevel::None => { // unit let mut s = serializer.serialize_struct("FolderSubscriptionLevel", 1)?; @@ -1260,7 +1260,7 @@ impl ::serde::ser::Serialize for ImportFormat { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ImportFormat::Html => { // unit let mut s = serializer.serialize_struct("ImportFormat", 1)?; @@ -1439,8 +1439,8 @@ impl ::serde::ser::Serialize for ListDocsCursorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListDocsCursorError::CursorError(ref x) => { + match self { + ListDocsCursorError::CursorError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListDocsCursorError", 2)?; s.serialize_field(".tag", "cursor_error")?; @@ -1759,7 +1759,7 @@ impl ::serde::ser::Serialize for ListPaperDocsFilterBy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListPaperDocsFilterBy::DocsAccessed => { // unit let mut s = serializer.serialize_struct("ListPaperDocsFilterBy", 1)?; @@ -1952,7 +1952,7 @@ impl ::serde::ser::Serialize for ListPaperDocsSortBy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListPaperDocsSortBy::Accessed => { // unit let mut s = serializer.serialize_struct("ListPaperDocsSortBy", 1)?; @@ -2023,7 +2023,7 @@ impl ::serde::ser::Serialize for ListPaperDocsSortOrder { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListPaperDocsSortOrder::Ascending => { // unit let mut s = serializer.serialize_struct("ListPaperDocsSortOrder", 1)?; @@ -2100,7 +2100,7 @@ impl ::serde::ser::Serialize for ListUsersCursorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListUsersCursorError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("ListUsersCursorError", 1)?; @@ -2113,7 +2113,7 @@ impl ::serde::ser::Serialize for ListUsersCursorError { s.serialize_field(".tag", "doc_not_found")?; s.end() } - ListUsersCursorError::CursorError(ref x) => { + ListUsersCursorError::CursorError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListUsersCursorError", 2)?; s.serialize_field(".tag", "cursor_error")?; @@ -2984,7 +2984,7 @@ impl ::serde::ser::Serialize for PaperApiBaseError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperApiBaseError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("PaperApiBaseError", 1)?; @@ -3061,7 +3061,7 @@ impl ::serde::ser::Serialize for PaperApiCursorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperApiCursorError::ExpiredCursor => { // unit let mut s = serializer.serialize_struct("PaperApiCursorError", 1)?; @@ -3281,7 +3281,7 @@ impl ::serde::ser::Serialize for PaperDocCreateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDocCreateError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("PaperDocCreateError", 1)?; @@ -3746,7 +3746,7 @@ impl ::serde::ser::Serialize for PaperDocPermissionLevel { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDocPermissionLevel::Edit => { // unit let mut s = serializer.serialize_struct("PaperDocPermissionLevel", 1)?; @@ -4095,7 +4095,7 @@ impl ::serde::ser::Serialize for PaperDocUpdateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDocUpdateError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?; @@ -4228,7 +4228,7 @@ impl ::serde::ser::Serialize for PaperDocUpdatePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDocUpdatePolicy::Append => { // unit let mut s = serializer.serialize_struct("PaperDocUpdatePolicy", 1)?; @@ -4442,7 +4442,7 @@ impl ::serde::ser::Serialize for PaperFolderCreateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperFolderCreateError::InsufficientPermissions => { // unit let mut s = serializer.serialize_struct("PaperFolderCreateError", 1)?; @@ -4934,7 +4934,7 @@ impl ::serde::ser::Serialize for SharingPublicPolicyType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharingPublicPolicyType::PeopleWithLinkCanEdit => { // unit let mut s = serializer.serialize_struct("SharingPublicPolicyType", 1)?; @@ -5020,7 +5020,7 @@ impl ::serde::ser::Serialize for SharingTeamPolicyType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharingTeamPolicyType::PeopleWithLinkCanEdit => { // unit let mut s = serializer.serialize_struct("SharingTeamPolicyType", 1)?; @@ -5198,7 +5198,7 @@ impl ::serde::ser::Serialize for UserOnPaperDocFilter { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UserOnPaperDocFilter::Visited => { // unit let mut s = serializer.serialize_struct("UserOnPaperDocFilter", 1)?; diff --git a/src/generated/types/seen_state.rs b/src/generated/types/seen_state.rs index 67acd3b..255886f 100644 --- a/src/generated/types/seen_state.rs +++ b/src/generated/types/seen_state.rs @@ -77,7 +77,7 @@ impl ::serde::ser::Serialize for PlatformType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PlatformType::Web => { // unit let mut s = serializer.serialize_struct("PlatformType", 1)?; diff --git a/src/generated/types/sharing.rs b/src/generated/types/sharing.rs index 3f0d4b3..eea8021 100644 --- a/src/generated/types/sharing.rs +++ b/src/generated/types/sharing.rs @@ -68,7 +68,7 @@ impl ::serde::ser::Serialize for AccessInheritance { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AccessInheritance::Inherit => { // unit let mut s = serializer.serialize_struct("AccessInheritance", 1)?; @@ -154,7 +154,7 @@ impl ::serde::ser::Serialize for AccessLevel { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AccessLevel::Owner => { // unit let mut s = serializer.serialize_struct("AccessLevel", 1)?; @@ -245,7 +245,7 @@ impl ::serde::ser::Serialize for AclUpdatePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AclUpdatePolicy::Owner => { // unit let mut s = serializer.serialize_struct("AclUpdatePolicy", 1)?; @@ -516,15 +516,15 @@ impl ::serde::ser::Serialize for AddFileMemberError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AddFileMemberError::UserError(ref x) => { + match self { + AddFileMemberError::UserError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AddFileMemberError", 2)?; s.serialize_field(".tag", "user_error")?; s.serialize_field("user_error", x)?; s.end() } - AddFileMemberError::AccessError(ref x) => { + AddFileMemberError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AddFileMemberError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -837,8 +837,8 @@ impl ::serde::ser::Serialize for AddFolderMemberError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AddFolderMemberError::AccessError(ref x) => { + match self { + AddFolderMemberError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AddFolderMemberError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -857,7 +857,7 @@ impl ::serde::ser::Serialize for AddFolderMemberError { s.serialize_field(".tag", "banned_member")?; s.end() } - AddFolderMemberError::BadMember(ref x) => { + AddFolderMemberError::BadMember(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AddFolderMemberError", 2)?; s.serialize_field(".tag", "bad_member")?; @@ -870,14 +870,14 @@ impl ::serde::ser::Serialize for AddFolderMemberError { s.serialize_field(".tag", "cant_share_outside_team")?; s.end() } - AddFolderMemberError::TooManyMembers(ref x) => { + AddFolderMemberError::TooManyMembers(x) => { // primitive let mut s = serializer.serialize_struct("AddFolderMemberError", 2)?; s.serialize_field(".tag", "too_many_members")?; s.serialize_field("too_many_members", x)?; s.end() } - AddFolderMemberError::TooManyPendingInvites(ref x) => { + AddFolderMemberError::TooManyPendingInvites(x) => { // primitive let mut s = serializer.serialize_struct("AddFolderMemberError", 2)?; s.serialize_field(".tag", "too_many_pending_invites")?; @@ -1151,28 +1151,28 @@ impl ::serde::ser::Serialize for AddMemberSelectorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AddMemberSelectorError::AutomaticGroup => { // unit let mut s = serializer.serialize_struct("AddMemberSelectorError", 1)?; s.serialize_field(".tag", "automatic_group")?; s.end() } - AddMemberSelectorError::InvalidDropboxId(ref x) => { + AddMemberSelectorError::InvalidDropboxId(x) => { // primitive let mut s = serializer.serialize_struct("AddMemberSelectorError", 2)?; s.serialize_field(".tag", "invalid_dropbox_id")?; s.serialize_field("invalid_dropbox_id", x)?; s.end() } - AddMemberSelectorError::InvalidEmail(ref x) => { + AddMemberSelectorError::InvalidEmail(x) => { // primitive let mut s = serializer.serialize_struct("AddMemberSelectorError", 2)?; s.serialize_field(".tag", "invalid_email")?; s.serialize_field("invalid_email", x)?; s.end() } - AddMemberSelectorError::UnverifiedDropboxId(ref x) => { + AddMemberSelectorError::UnverifiedDropboxId(x) => { // primitive let mut s = serializer.serialize_struct("AddMemberSelectorError", 2)?; s.serialize_field(".tag", "unverified_dropbox_id")?; @@ -1284,7 +1284,7 @@ impl ::serde::ser::Serialize for AlphaResolvedVisibility { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AlphaResolvedVisibility::Public => { // unit let mut s = serializer.serialize_struct("AlphaResolvedVisibility", 1)?; @@ -1980,8 +1980,8 @@ impl ::serde::ser::Serialize for CreateSharedLinkError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - CreateSharedLinkError::Path(ref x) => { + match self { + CreateSharedLinkError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CreateSharedLinkError", 2)?; s.serialize_field(".tag", "path")?; @@ -2199,8 +2199,8 @@ impl ::serde::ser::Serialize for CreateSharedLinkWithSettingsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - CreateSharedLinkWithSettingsError::Path(ref x) => { + match self { + CreateSharedLinkWithSettingsError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CreateSharedLinkWithSettingsError", 2)?; s.serialize_field(".tag", "path")?; @@ -2213,14 +2213,14 @@ impl ::serde::ser::Serialize for CreateSharedLinkWithSettingsError { s.serialize_field(".tag", "email_not_verified")?; s.end() } - CreateSharedLinkWithSettingsError::SharedLinkAlreadyExists(ref x) => { + CreateSharedLinkWithSettingsError::SharedLinkAlreadyExists(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CreateSharedLinkWithSettingsError", 2)?; s.serialize_field(".tag", "shared_link_already_exists")?; s.serialize_field("shared_link_already_exists", x)?; s.end() } - CreateSharedLinkWithSettingsError::SettingsError(ref x) => { + CreateSharedLinkWithSettingsError::SettingsError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CreateSharedLinkWithSettingsError", 2)?; s.serialize_field(".tag", "settings_error")?; @@ -2565,7 +2565,7 @@ impl ::serde::ser::Serialize for FileAction { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileAction::DisableViewerInfo => { // unit let mut s = serializer.serialize_struct("FileAction", 1)?; @@ -2712,22 +2712,22 @@ impl ::serde::ser::Serialize for FileErrorResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - FileErrorResult::FileNotFoundError(ref x) => { + match self { + FileErrorResult::FileNotFoundError(x) => { // primitive let mut s = serializer.serialize_struct("FileErrorResult", 2)?; s.serialize_field(".tag", "file_not_found_error")?; s.serialize_field("file_not_found_error", x)?; s.end() } - FileErrorResult::InvalidFileActionError(ref x) => { + FileErrorResult::InvalidFileActionError(x) => { // primitive let mut s = serializer.serialize_struct("FileErrorResult", 2)?; s.serialize_field(".tag", "invalid_file_action_error")?; s.serialize_field("invalid_file_action_error", x)?; s.end() } - FileErrorResult::PermissionDeniedError(ref x) => { + FileErrorResult::PermissionDeniedError(x) => { // primitive let mut s = serializer.serialize_struct("FileErrorResult", 2)?; s.serialize_field(".tag", "permission_denied_error")?; @@ -3094,7 +3094,7 @@ impl ::serde::ser::Serialize for FileMemberActionError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileMemberActionError::InvalidMember => { // unit let mut s = serializer.serialize_struct("FileMemberActionError", 1)?; @@ -3107,14 +3107,14 @@ impl ::serde::ser::Serialize for FileMemberActionError { s.serialize_field(".tag", "no_permission")?; s.end() } - FileMemberActionError::AccessError(ref x) => { + FileMemberActionError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("FileMemberActionError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - FileMemberActionError::NoExplicitAccess(ref x) => { + FileMemberActionError::NoExplicitAccess(x) => { // struct let mut s = serializer.serialize_struct("FileMemberActionError", 4)?; s.serialize_field(".tag", "no_explicit_access")?; @@ -3204,15 +3204,15 @@ impl ::serde::ser::Serialize for FileMemberActionIndividualResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - FileMemberActionIndividualResult::Success(ref x) => { + match self { + FileMemberActionIndividualResult::Success(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("FileMemberActionIndividualResult", 2)?; s.serialize_field(".tag", "success")?; s.serialize_field("success", x)?; s.end() } - FileMemberActionIndividualResult::MemberError(ref x) => { + FileMemberActionIndividualResult::MemberError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("FileMemberActionIndividualResult", 2)?; s.serialize_field(".tag", "member_error")?; @@ -3422,15 +3422,15 @@ impl ::serde::ser::Serialize for FileMemberRemoveActionResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - FileMemberRemoveActionResult::Success(ref x) => { + match self { + FileMemberRemoveActionResult::Success(x) => { // struct let mut s = serializer.serialize_struct("FileMemberRemoveActionResult", 4)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - FileMemberRemoveActionResult::MemberError(ref x) => { + FileMemberRemoveActionResult::MemberError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("FileMemberRemoveActionResult", 2)?; s.serialize_field(".tag", "member_error")?; @@ -3663,7 +3663,7 @@ impl ::serde::ser::Serialize for FolderAction { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FolderAction::ChangeOptions => { // unit let mut s = serializer.serialize_struct("FolderAction", 1)?; @@ -4668,15 +4668,15 @@ impl ::serde::ser::Serialize for GetFileMetadataError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GetFileMetadataError::UserError(ref x) => { + match self { + GetFileMetadataError::UserError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("GetFileMetadataError", 2)?; s.serialize_field(".tag", "user_error")?; s.serialize_field("user_error", x)?; s.end() } - GetFileMetadataError::AccessError(ref x) => { + GetFileMetadataError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("GetFileMetadataError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -4761,15 +4761,15 @@ impl ::serde::ser::Serialize for GetFileMetadataIndividualResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GetFileMetadataIndividualResult::Metadata(ref x) => { + match self { + GetFileMetadataIndividualResult::Metadata(x) => { // struct let mut s = serializer.serialize_struct("GetFileMetadataIndividualResult", 15)?; s.serialize_field(".tag", "metadata")?; x.internal_serialize::(&mut s)?; s.end() } - GetFileMetadataIndividualResult::AccessError(ref x) => { + GetFileMetadataIndividualResult::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("GetFileMetadataIndividualResult", 2)?; s.serialize_field(".tag", "access_error")?; @@ -4949,7 +4949,7 @@ impl ::serde::ser::Serialize for GetSharedLinkFileError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GetSharedLinkFileError::SharedLinkNotFound => { // unit let mut s = serializer.serialize_struct("GetSharedLinkFileError", 1)?; @@ -5265,13 +5265,13 @@ impl ::serde::ser::Serialize for GetSharedLinksError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GetSharedLinksError::Path(ref x) => { + match self { + GetSharedLinksError::Path(x) => { // nullable (struct or primitive) let n = if x.is_some() { 2 } else { 1 }; let mut s = serializer.serialize_struct("GetSharedLinksError", n)?; s.serialize_field(".tag", "path")?; - if let Some(ref x) = x { + if let Some(x) = x { s.serialize_field("path", &x)?; } s.end() @@ -6073,8 +6073,8 @@ impl ::serde::ser::Serialize for InviteeInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - InviteeInfo::Email(ref x) => { + match self { + InviteeInfo::Email(x) => { // primitive let mut s = serializer.serialize_struct("InviteeInfo", 2)?; s.serialize_field(".tag", "email")?; @@ -6358,22 +6358,22 @@ impl ::serde::ser::Serialize for JobError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - JobError::UnshareFolderError(ref x) => { + match self { + JobError::UnshareFolderError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("JobError", 2)?; s.serialize_field(".tag", "unshare_folder_error")?; s.serialize_field("unshare_folder_error", x)?; s.end() } - JobError::RemoveFolderMemberError(ref x) => { + JobError::RemoveFolderMemberError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("JobError", 2)?; s.serialize_field(".tag", "remove_folder_member_error")?; s.serialize_field("remove_folder_member_error", x)?; s.end() } - JobError::RelinquishFolderMembershipError(ref x) => { + JobError::RelinquishFolderMembershipError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("JobError", 2)?; s.serialize_field(".tag", "relinquish_folder_membership_error")?; @@ -6459,7 +6459,7 @@ impl ::serde::ser::Serialize for JobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { JobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("JobStatus", 1)?; @@ -6472,7 +6472,7 @@ impl ::serde::ser::Serialize for JobStatus { s.serialize_field(".tag", "complete")?; s.end() } - JobStatus::Failed(ref x) => { + JobStatus::Failed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("JobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -6538,7 +6538,7 @@ impl ::serde::ser::Serialize for LinkAccessLevel { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LinkAccessLevel::Viewer => { // unit let mut s = serializer.serialize_struct("LinkAccessLevel", 1)?; @@ -6620,7 +6620,7 @@ impl ::serde::ser::Serialize for LinkAction { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LinkAction::ChangeAccessLevel => { // unit let mut s = serializer.serialize_struct("LinkAction", 1)?; @@ -6724,7 +6724,7 @@ impl ::serde::ser::Serialize for LinkAudience { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LinkAudience::Public => { // unit let mut s = serializer.serialize_struct("LinkAudience", 1)?; @@ -6825,7 +6825,7 @@ impl ::serde::ser::Serialize for LinkAudienceDisallowedReason { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LinkAudienceDisallowedReason::DeleteAndRecreate => { // unit let mut s = serializer.serialize_struct("LinkAudienceDisallowedReason", 1)?; @@ -7059,14 +7059,14 @@ impl ::serde::ser::Serialize for LinkExpiry { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LinkExpiry::RemoveExpiry => { // unit let mut s = serializer.serialize_struct("LinkExpiry", 1)?; s.serialize_field(".tag", "remove_expiry")?; s.end() } - LinkExpiry::SetExpiry(ref x) => { + LinkExpiry::SetExpiry(x) => { // primitive let mut s = serializer.serialize_struct("LinkExpiry", 2)?; s.serialize_field(".tag", "set_expiry")?; @@ -7125,14 +7125,14 @@ impl ::serde::ser::Serialize for LinkMetadata { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - LinkMetadata::Path(ref x) => { + match self { + LinkMetadata::Path(x) => { let mut s = serializer.serialize_struct("LinkMetadata", 5)?; s.serialize_field(".tag", "path")?; x.internal_serialize::(&mut s)?; s.end() } - LinkMetadata::Collection(ref x) => { + LinkMetadata::Collection(x) => { let mut s = serializer.serialize_struct("LinkMetadata", 4)?; s.serialize_field(".tag", "collection")?; x.internal_serialize::(&mut s)?; @@ -7196,14 +7196,14 @@ impl ::serde::ser::Serialize for LinkPassword { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LinkPassword::RemovePassword => { // unit let mut s = serializer.serialize_struct("LinkPassword", 1)?; s.serialize_field(".tag", "remove_password")?; s.end() } - LinkPassword::SetPassword(ref x) => { + LinkPassword::SetPassword(x) => { // primitive let mut s = serializer.serialize_struct("LinkPassword", 2)?; s.serialize_field(".tag", "set_password")?; @@ -8426,15 +8426,15 @@ impl ::serde::ser::Serialize for ListFileMembersContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListFileMembersContinueError::UserError(ref x) => { + match self { + ListFileMembersContinueError::UserError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFileMembersContinueError", 2)?; s.serialize_field(".tag", "user_error")?; s.serialize_field("user_error", x)?; s.end() } - ListFileMembersContinueError::AccessError(ref x) => { + ListFileMembersContinueError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFileMembersContinueError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -8634,15 +8634,15 @@ impl ::serde::ser::Serialize for ListFileMembersError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListFileMembersError::UserError(ref x) => { + match self { + ListFileMembersError::UserError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFileMembersError", 2)?; s.serialize_field(".tag", "user_error")?; s.serialize_field("user_error", x)?; s.end() } - ListFileMembersError::AccessError(ref x) => { + ListFileMembersError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFileMembersError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -8727,15 +8727,15 @@ impl ::serde::ser::Serialize for ListFileMembersIndividualResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListFileMembersIndividualResult::Result(ref x) => { + match self { + ListFileMembersIndividualResult::Result(x) => { // struct let mut s = serializer.serialize_struct("ListFileMembersIndividualResult", 3)?; s.serialize_field(".tag", "result")?; x.internal_serialize::(&mut s)?; s.end() } - ListFileMembersIndividualResult::AccessError(ref x) => { + ListFileMembersIndividualResult::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFileMembersIndividualResult", 2)?; s.serialize_field(".tag", "access_error")?; @@ -9006,8 +9006,8 @@ impl ::serde::ser::Serialize for ListFilesContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListFilesContinueError::UserError(ref x) => { + match self { + ListFilesContinueError::UserError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFilesContinueError", 2)?; s.serialize_field(".tag", "user_error")?; @@ -9443,8 +9443,8 @@ impl ::serde::ser::Serialize for ListFolderMembersContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListFolderMembersContinueError::AccessError(ref x) => { + match self { + ListFolderMembersContinueError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListFolderMembersContinueError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -9837,7 +9837,7 @@ impl ::serde::ser::Serialize for ListFoldersContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListFoldersContinueError::InvalidCursor => { // unit let mut s = serializer.serialize_struct("ListFoldersContinueError", 1)?; @@ -10150,8 +10150,8 @@ impl ::serde::ser::Serialize for ListSharedLinksError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ListSharedLinksError::Path(ref x) => { + match self { + ListSharedLinksError::Path(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ListSharedLinksError", 2)?; s.serialize_field(".tag", "path")?; @@ -10499,7 +10499,7 @@ impl ::serde::ser::Serialize for MemberAction { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberAction::LeaveACopy => { // unit let mut s = serializer.serialize_struct("MemberAction", 1)?; @@ -10715,7 +10715,7 @@ impl ::serde::ser::Serialize for MemberPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberPolicy::Team => { // unit let mut s = serializer.serialize_struct("MemberPolicy", 1)?; @@ -10793,15 +10793,15 @@ impl ::serde::ser::Serialize for MemberSelector { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MemberSelector::DropboxId(ref x) => { + match self { + MemberSelector::DropboxId(x) => { // primitive let mut s = serializer.serialize_struct("MemberSelector", 2)?; s.serialize_field(".tag", "dropbox_id")?; s.serialize_field("dropbox_id", x)?; s.end() } - MemberSelector::Email(ref x) => { + MemberSelector::Email(x) => { // primitive let mut s = serializer.serialize_struct("MemberSelector", 2)?; s.serialize_field(".tag", "email")?; @@ -11158,7 +11158,7 @@ impl ::serde::ser::Serialize for ModifySharedLinkSettingsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ModifySharedLinkSettingsError::SharedLinkNotFound => { // unit let mut s = serializer.serialize_struct("ModifySharedLinkSettingsError", 1)?; @@ -11177,7 +11177,7 @@ impl ::serde::ser::Serialize for ModifySharedLinkSettingsError { s.serialize_field(".tag", "unsupported_link_type")?; s.end() } - ModifySharedLinkSettingsError::SettingsError(ref x) => { + ModifySharedLinkSettingsError::SettingsError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ModifySharedLinkSettingsError", 2)?; s.serialize_field(".tag", "settings_error")?; @@ -11386,8 +11386,8 @@ impl ::serde::ser::Serialize for MountFolderError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MountFolderError::AccessError(ref x) => { + match self { + MountFolderError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("MountFolderError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -11400,7 +11400,7 @@ impl ::serde::ser::Serialize for MountFolderError { s.serialize_field(".tag", "inside_shared_folder")?; s.end() } - MountFolderError::InsufficientQuota(ref x) => { + MountFolderError::InsufficientQuota(x) => { // struct let mut s = serializer.serialize_struct("MountFolderError", 4)?; s.serialize_field(".tag", "insufficient_quota")?; @@ -11776,7 +11776,7 @@ impl ::serde::ser::Serialize for PendingUploadMode { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PendingUploadMode::File => { // unit let mut s = serializer.serialize_struct("PendingUploadMode", 1)?; @@ -11892,7 +11892,7 @@ impl ::serde::ser::Serialize for PermissionDeniedReason { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PermissionDeniedReason::UserNotSameTeamAsOwner => { // unit let mut s = serializer.serialize_struct("PermissionDeniedReason", 1)?; @@ -11977,7 +11977,7 @@ impl ::serde::ser::Serialize for PermissionDeniedReason { s.serialize_field(".tag", "restricted_by_parent_folder")?; s.end() } - PermissionDeniedReason::InsufficientPlan(ref x) => { + PermissionDeniedReason::InsufficientPlan(x) => { // struct let mut s = serializer.serialize_struct("PermissionDeniedReason", 3)?; s.serialize_field(".tag", "insufficient_plan")?; @@ -12137,8 +12137,8 @@ impl ::serde::ser::Serialize for RelinquishFileMembershipError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RelinquishFileMembershipError::AccessError(ref x) => { + match self { + RelinquishFileMembershipError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelinquishFileMembershipError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -12370,8 +12370,8 @@ impl ::serde::ser::Serialize for RelinquishFolderMembershipError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RelinquishFolderMembershipError::AccessError(ref x) => { + match self { + RelinquishFolderMembershipError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RelinquishFolderMembershipError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -12613,22 +12613,22 @@ impl ::serde::ser::Serialize for RemoveFileMemberError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RemoveFileMemberError::UserError(ref x) => { + match self { + RemoveFileMemberError::UserError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemoveFileMemberError", 2)?; s.serialize_field(".tag", "user_error")?; s.serialize_field("user_error", x)?; s.end() } - RemoveFileMemberError::AccessError(ref x) => { + RemoveFileMemberError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemoveFileMemberError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - RemoveFileMemberError::NoExplicitAccess(ref x) => { + RemoveFileMemberError::NoExplicitAccess(x) => { // struct let mut s = serializer.serialize_struct("RemoveFileMemberError", 4)?; s.serialize_field(".tag", "no_explicit_access")?; @@ -12863,15 +12863,15 @@ impl ::serde::ser::Serialize for RemoveFolderMemberError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RemoveFolderMemberError::AccessError(ref x) => { + match self { + RemoveFolderMemberError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemoveFolderMemberError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - RemoveFolderMemberError::MemberError(ref x) => { + RemoveFolderMemberError::MemberError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemoveFolderMemberError", 2)?; s.serialize_field(".tag", "member_error")?; @@ -12990,21 +12990,21 @@ impl ::serde::ser::Serialize for RemoveMemberJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RemoveMemberJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("RemoveMemberJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - RemoveMemberJobStatus::Complete(ref x) => { + RemoveMemberJobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("RemoveMemberJobStatus", 4)?; s.serialize_field(".tag", "complete")?; x.internal_serialize::(&mut s)?; s.end() } - RemoveMemberJobStatus::Failed(ref x) => { + RemoveMemberJobStatus::Failed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemoveMemberJobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -13079,7 +13079,7 @@ impl ::serde::ser::Serialize for RequestedLinkAccessLevel { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RequestedLinkAccessLevel::Viewer => { // unit let mut s = serializer.serialize_struct("RequestedLinkAccessLevel", 1)?; @@ -13159,7 +13159,7 @@ impl ::serde::ser::Serialize for RequestedVisibility { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RequestedVisibility::Public => { // unit let mut s = serializer.serialize_struct("RequestedVisibility", 1)?; @@ -13256,7 +13256,7 @@ impl ::serde::ser::Serialize for ResolvedVisibility { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ResolvedVisibility::Public => { // unit let mut s = serializer.serialize_struct("ResolvedVisibility", 1)?; @@ -13460,7 +13460,7 @@ impl ::serde::ser::Serialize for RevokeSharedLinkError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RevokeSharedLinkError::SharedLinkNotFound => { // unit let mut s = serializer.serialize_struct("RevokeSharedLinkError", 1)?; @@ -13679,8 +13679,8 @@ impl ::serde::ser::Serialize for SetAccessInheritanceError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SetAccessInheritanceError::AccessError(ref x) => { + match self { + SetAccessInheritanceError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("SetAccessInheritanceError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -14267,14 +14267,14 @@ impl ::serde::ser::Serialize for ShareFolderError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShareFolderError::EmailUnverified => { // unit let mut s = serializer.serialize_struct("ShareFolderError", 1)?; s.serialize_field(".tag", "email_unverified")?; s.end() } - ShareFolderError::BadPath(ref x) => { + ShareFolderError::BadPath(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ShareFolderError", 2)?; s.serialize_field(".tag", "bad_path")?; @@ -14399,14 +14399,14 @@ impl ::serde::ser::Serialize for ShareFolderErrorBase { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShareFolderErrorBase::EmailUnverified => { // unit let mut s = serializer.serialize_struct("ShareFolderErrorBase", 1)?; s.serialize_field(".tag", "email_unverified")?; s.end() } - ShareFolderErrorBase::BadPath(ref x) => { + ShareFolderErrorBase::BadPath(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ShareFolderErrorBase", 2)?; s.serialize_field(".tag", "bad_path")?; @@ -14481,21 +14481,21 @@ impl ::serde::ser::Serialize for ShareFolderJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShareFolderJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("ShareFolderJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - ShareFolderJobStatus::Complete(ref x) => { + ShareFolderJobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("ShareFolderJobStatus", 18)?; s.serialize_field(".tag", "complete")?; x.internal_serialize::(&mut s)?; s.end() } - ShareFolderJobStatus::Failed(ref x) => { + ShareFolderJobStatus::Failed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ShareFolderJobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -14562,15 +14562,15 @@ impl ::serde::ser::Serialize for ShareFolderLaunch { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ShareFolderLaunch::AsyncJobId(ref x) => { + match self { + ShareFolderLaunch::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("ShareFolderLaunch", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - ShareFolderLaunch::Complete(ref x) => { + ShareFolderLaunch::Complete(x) => { // struct let mut s = serializer.serialize_struct("ShareFolderLaunch", 18)?; s.serialize_field(".tag", "complete")?; @@ -14692,7 +14692,7 @@ impl ::serde::ser::Serialize for SharePathError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharePathError::IsFile => { // unit let mut s = serializer.serialize_struct("SharePathError", 1)?; @@ -14747,7 +14747,7 @@ impl ::serde::ser::Serialize for SharePathError { s.serialize_field(".tag", "inside_public_folder")?; s.end() } - SharePathError::AlreadyShared(ref x) => { + SharePathError::AlreadyShared(x) => { // struct let mut s = serializer.serialize_struct("SharePathError", 18)?; s.serialize_field(".tag", "already_shared")?; @@ -15837,7 +15837,7 @@ impl ::serde::ser::Serialize for SharedFolderAccessError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedFolderAccessError::InvalidId => { // unit let mut s = serializer.serialize_struct("SharedFolderAccessError", 1)?; @@ -15940,7 +15940,7 @@ impl ::serde::ser::Serialize for SharedFolderMemberError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedFolderMemberError::InvalidDropboxId => { // unit let mut s = serializer.serialize_struct("SharedFolderMemberError", 1)?; @@ -15953,7 +15953,7 @@ impl ::serde::ser::Serialize for SharedFolderMemberError { s.serialize_field(".tag", "not_a_member")?; s.end() } - SharedFolderMemberError::NoExplicitAccess(ref x) => { + SharedFolderMemberError::NoExplicitAccess(x) => { // struct let mut s = serializer.serialize_struct("SharedFolderMemberError", 4)?; s.serialize_field(".tag", "no_explicit_access")?; @@ -16831,7 +16831,7 @@ impl ::serde::ser::Serialize for SharedLinkAccessFailureReason { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedLinkAccessFailureReason::LoginRequired => { // unit let mut s = serializer.serialize_struct("SharedLinkAccessFailureReason", 1)?; @@ -16916,8 +16916,8 @@ impl ::serde::ser::Serialize for SharedLinkAlreadyExistsMetadata { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SharedLinkAlreadyExistsMetadata::Metadata(ref x) => { + match self { + SharedLinkAlreadyExistsMetadata::Metadata(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("SharedLinkAlreadyExistsMetadata", 2)?; s.serialize_field(".tag", "metadata")?; @@ -16980,7 +16980,7 @@ impl ::serde::ser::Serialize for SharedLinkError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedLinkError::SharedLinkNotFound => { // unit let mut s = serializer.serialize_struct("SharedLinkError", 1)?; @@ -17063,14 +17063,14 @@ impl ::serde::ser::Serialize for SharedLinkMetadata { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - SharedLinkMetadata::File(ref x) => { + match self { + SharedLinkMetadata::File(x) => { let mut s = serializer.serialize_struct("SharedLinkMetadata", 13)?; s.serialize_field(".tag", "file")?; x.internal_serialize::(&mut s)?; s.end() } - SharedLinkMetadata::Folder(ref x) => { + SharedLinkMetadata::Folder(x) => { let mut s = serializer.serialize_struct("SharedLinkMetadata", 9)?; s.serialize_field(".tag", "folder")?; x.internal_serialize::(&mut s)?; @@ -17133,7 +17133,7 @@ impl ::serde::ser::Serialize for SharedLinkPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedLinkPolicy::Anyone => { // unit let mut s = serializer.serialize_struct("SharedLinkPolicy", 1)?; @@ -17404,7 +17404,7 @@ impl ::serde::ser::Serialize for SharedLinkSettingsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedLinkSettingsError::InvalidSettings => { // unit let mut s = serializer.serialize_struct("SharedLinkSettingsError", 1)?; @@ -17490,7 +17490,7 @@ impl ::serde::ser::Serialize for SharingFileAccessError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharingFileAccessError::NoPermission => { // unit let mut s = serializer.serialize_struct("SharingFileAccessError", 1)?; @@ -17588,7 +17588,7 @@ impl ::serde::ser::Serialize for SharingUserError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharingUserError::EmailUnverified => { // unit let mut s = serializer.serialize_struct("SharingUserError", 1)?; @@ -17916,8 +17916,8 @@ impl ::serde::ser::Serialize for TransferFolderError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TransferFolderError::AccessError(ref x) => { + match self { + TransferFolderError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TransferFolderError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -18135,8 +18135,8 @@ impl ::serde::ser::Serialize for UnmountFolderError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UnmountFolderError::AccessError(ref x) => { + match self { + UnmountFolderError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UnmountFolderError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -18330,15 +18330,15 @@ impl ::serde::ser::Serialize for UnshareFileError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UnshareFileError::UserError(ref x) => { + match self { + UnshareFileError::UserError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UnshareFileError", 2)?; s.serialize_field(".tag", "user_error")?; s.serialize_field("user_error", x)?; s.end() } - UnshareFileError::AccessError(ref x) => { + UnshareFileError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UnshareFileError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -18543,8 +18543,8 @@ impl ::serde::ser::Serialize for UnshareFolderError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UnshareFolderError::AccessError(ref x) => { + match self { + UnshareFolderError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UnshareFolderError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -18913,22 +18913,22 @@ impl ::serde::ser::Serialize for UpdateFolderMemberError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UpdateFolderMemberError::AccessError(ref x) => { + match self { + UpdateFolderMemberError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UpdateFolderMemberError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - UpdateFolderMemberError::MemberError(ref x) => { + UpdateFolderMemberError::MemberError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UpdateFolderMemberError", 2)?; s.serialize_field(".tag", "member_error")?; s.serialize_field("member_error", x)?; s.end() } - UpdateFolderMemberError::NoExplicitAccess(ref x) => { + UpdateFolderMemberError::NoExplicitAccess(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UpdateFolderMemberError", 2)?; s.serialize_field(".tag", "no_explicit_access")?; @@ -19261,8 +19261,8 @@ impl ::serde::ser::Serialize for UpdateFolderPolicyError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UpdateFolderPolicyError::AccessError(ref x) => { + match self { + UpdateFolderPolicyError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UpdateFolderPolicyError", 2)?; s.serialize_field(".tag", "access_error")?; @@ -19927,7 +19927,7 @@ impl ::serde::ser::Serialize for ViewerInfoPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ViewerInfoPolicy::Enabled => { // unit let mut s = serializer.serialize_struct("ViewerInfoPolicy", 1)?; @@ -20007,7 +20007,7 @@ impl ::serde::ser::Serialize for Visibility { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { Visibility::Public => { // unit let mut s = serializer.serialize_struct("Visibility", 1)?; @@ -20251,7 +20251,7 @@ impl ::serde::ser::Serialize for VisibilityPolicyDisallowedReason { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { VisibilityPolicyDisallowedReason::DeleteAndRecreate => { // unit let mut s = serializer.serialize_struct("VisibilityPolicyDisallowedReason", 1)?; diff --git a/src/generated/types/team.rs b/src/generated/types/team.rs index 05b890c..12f021e 100644 --- a/src/generated/types/team.rs +++ b/src/generated/types/team.rs @@ -392,64 +392,64 @@ impl ::serde::ser::Serialize for AddSecondaryEmailResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AddSecondaryEmailResult::Success(ref x) => { + match self { + AddSecondaryEmailResult::Success(x) => { // struct let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 3)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - AddSecondaryEmailResult::Unavailable(ref x) => { + AddSecondaryEmailResult::Unavailable(x) => { // primitive let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 2)?; s.serialize_field(".tag", "unavailable")?; s.serialize_field("unavailable", x)?; s.end() } - AddSecondaryEmailResult::AlreadyPending(ref x) => { + AddSecondaryEmailResult::AlreadyPending(x) => { // primitive let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 2)?; s.serialize_field(".tag", "already_pending")?; s.serialize_field("already_pending", x)?; s.end() } - AddSecondaryEmailResult::AlreadyOwnedByUser(ref x) => { + AddSecondaryEmailResult::AlreadyOwnedByUser(x) => { // primitive let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 2)?; s.serialize_field(".tag", "already_owned_by_user")?; s.serialize_field("already_owned_by_user", x)?; s.end() } - AddSecondaryEmailResult::ReachedLimit(ref x) => { + AddSecondaryEmailResult::ReachedLimit(x) => { // primitive let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 2)?; s.serialize_field(".tag", "reached_limit")?; s.serialize_field("reached_limit", x)?; s.end() } - AddSecondaryEmailResult::TransientError(ref x) => { + AddSecondaryEmailResult::TransientError(x) => { // primitive let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 2)?; s.serialize_field(".tag", "transient_error")?; s.serialize_field("transient_error", x)?; s.end() } - AddSecondaryEmailResult::TooManyUpdates(ref x) => { + AddSecondaryEmailResult::TooManyUpdates(x) => { // primitive let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 2)?; s.serialize_field(".tag", "too_many_updates")?; s.serialize_field("too_many_updates", x)?; s.end() } - AddSecondaryEmailResult::UnknownError(ref x) => { + AddSecondaryEmailResult::UnknownError(x) => { // primitive let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 2)?; s.serialize_field(".tag", "unknown_error")?; s.serialize_field("unknown_error", x)?; s.end() } - AddSecondaryEmailResult::RateLimited(ref x) => { + AddSecondaryEmailResult::RateLimited(x) => { // primitive let mut s = serializer.serialize_struct("AddSecondaryEmailResult", 2)?; s.serialize_field(".tag", "rate_limited")?; @@ -600,7 +600,7 @@ impl ::serde::ser::Serialize for AddSecondaryEmailsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AddSecondaryEmailsError::SecondaryEmailsDisabled => { // unit let mut s = serializer.serialize_struct("AddSecondaryEmailsError", 1)?; @@ -774,7 +774,7 @@ impl ::serde::ser::Serialize for AdminTier { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminTier::TeamAdmin => { // unit let mut s = serializer.serialize_struct("AdminTier", 1)?; @@ -1140,22 +1140,22 @@ impl ::serde::ser::Serialize for BaseTeamFolderError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - BaseTeamFolderError::AccessError(ref x) => { + match self { + BaseTeamFolderError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("BaseTeamFolderError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - BaseTeamFolderError::StatusError(ref x) => { + BaseTeamFolderError::StatusError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("BaseTeamFolderError", 2)?; s.serialize_field(".tag", "status_error")?; s.serialize_field("status_error", x)?; s.end() } - BaseTeamFolderError::TeamSharedDropboxError(ref x) => { + BaseTeamFolderError::TeamSharedDropboxError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("BaseTeamFolderError", 2)?; s.serialize_field(".tag", "team_shared_dropbox_error")?; @@ -1233,7 +1233,7 @@ impl ::serde::ser::Serialize for CustomQuotaError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { CustomQuotaError::TooManyUsers => { // unit let mut s = serializer.serialize_struct("CustomQuotaError", 1)?; @@ -1311,15 +1311,15 @@ impl ::serde::ser::Serialize for CustomQuotaResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - CustomQuotaResult::Success(ref x) => { + match self { + CustomQuotaResult::Success(x) => { // struct let mut s = serializer.serialize_struct("CustomQuotaResult", 3)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - CustomQuotaResult::InvalidUser(ref x) => { + CustomQuotaResult::InvalidUser(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("CustomQuotaResult", 2)?; s.serialize_field(".tag", "invalid_user")?; @@ -1648,22 +1648,22 @@ impl ::serde::ser::Serialize for DeleteSecondaryEmailResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - DeleteSecondaryEmailResult::Success(ref x) => { + match self { + DeleteSecondaryEmailResult::Success(x) => { // primitive let mut s = serializer.serialize_struct("DeleteSecondaryEmailResult", 2)?; s.serialize_field(".tag", "success")?; s.serialize_field("success", x)?; s.end() } - DeleteSecondaryEmailResult::NotFound(ref x) => { + DeleteSecondaryEmailResult::NotFound(x) => { // primitive let mut s = serializer.serialize_struct("DeleteSecondaryEmailResult", 2)?; s.serialize_field(".tag", "not_found")?; s.serialize_field("not_found", x)?; s.end() } - DeleteSecondaryEmailResult::CannotRemovePrimary(ref x) => { + DeleteSecondaryEmailResult::CannotRemovePrimary(x) => { // primitive let mut s = serializer.serialize_struct("DeleteSecondaryEmailResult", 2)?; s.serialize_field(".tag", "cannot_remove_primary")?; @@ -2163,7 +2163,7 @@ impl ::serde::ser::Serialize for DesktopPlatform { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DesktopPlatform::Windows => { // unit let mut s = serializer.serialize_struct("DesktopPlatform", 1)?; @@ -2868,7 +2868,7 @@ impl ::serde::ser::Serialize for ExcludedUsersListContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExcludedUsersListContinueError::InvalidCursor => { // unit let mut s = serializer.serialize_struct("ExcludedUsersListContinueError", 1)?; @@ -2936,7 +2936,7 @@ impl ::serde::ser::Serialize for ExcludedUsersListError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExcludedUsersListError::ListError => { // unit let mut s = serializer.serialize_struct("ExcludedUsersListError", 1)?; @@ -3220,7 +3220,7 @@ impl ::serde::ser::Serialize for ExcludedUsersUpdateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExcludedUsersUpdateError::UsersNotInTeam => { // unit let mut s = serializer.serialize_struct("ExcludedUsersUpdateError", 1)?; @@ -3387,7 +3387,7 @@ impl ::serde::ser::Serialize for ExcludedUsersUpdateStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExcludedUsersUpdateStatus::Success => { // unit let mut s = serializer.serialize_struct("ExcludedUsersUpdateStatus", 1)?; @@ -3455,7 +3455,7 @@ impl ::serde::ser::Serialize for Feature { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { Feature::UploadApiRateLimit => { // unit let mut s = serializer.serialize_struct("Feature", 1)?; @@ -3562,29 +3562,29 @@ impl ::serde::ser::Serialize for FeatureValue { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - FeatureValue::UploadApiRateLimit(ref x) => { + match self { + FeatureValue::UploadApiRateLimit(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("FeatureValue", 2)?; s.serialize_field(".tag", "upload_api_rate_limit")?; s.serialize_field("upload_api_rate_limit", x)?; s.end() } - FeatureValue::HasTeamSharedDropbox(ref x) => { + FeatureValue::HasTeamSharedDropbox(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("FeatureValue", 2)?; s.serialize_field(".tag", "has_team_shared_dropbox")?; s.serialize_field("has_team_shared_dropbox", x)?; s.end() } - FeatureValue::HasTeamFileEvents(ref x) => { + FeatureValue::HasTeamFileEvents(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("FeatureValue", 2)?; s.serialize_field(".tag", "has_team_file_events")?; s.serialize_field("has_team_file_events", x)?; s.end() } - FeatureValue::HasTeamSelectiveSync(ref x) => { + FeatureValue::HasTeamSelectiveSync(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("FeatureValue", 2)?; s.serialize_field(".tag", "has_team_selective_sync")?; @@ -3732,7 +3732,7 @@ impl ::serde::ser::Serialize for FeaturesGetValuesBatchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FeaturesGetValuesBatchError::EmptyFeaturesList => { // unit let mut s = serializer.serialize_struct("FeaturesGetValuesBatchError", 1)?; @@ -4682,7 +4682,7 @@ impl ::serde::ser::Serialize for GroupAccessType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupAccessType::Member => { // unit let mut s = serializer.serialize_struct("GroupAccessType", 1)?; @@ -4911,7 +4911,7 @@ impl ::serde::ser::Serialize for GroupCreateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupCreateError::GroupNameAlreadyUsed => { // unit let mut s = serializer.serialize_struct("GroupCreateError", 1)?; @@ -5007,7 +5007,7 @@ impl ::serde::ser::Serialize for GroupDeleteError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupDeleteError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupDeleteError", 1)?; @@ -5527,7 +5527,7 @@ impl ::serde::ser::Serialize for GroupMemberSelectorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupMemberSelectorError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupMemberSelectorError", 1)?; @@ -5630,7 +5630,7 @@ impl ::serde::ser::Serialize for GroupMemberSetAccessTypeError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupMemberSetAccessTypeError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupMemberSetAccessTypeError", 1)?; @@ -5913,7 +5913,7 @@ impl ::serde::ser::Serialize for GroupMembersAddError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupMembersAddError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupMembersAddError", 1)?; @@ -5938,14 +5938,14 @@ impl ::serde::ser::Serialize for GroupMembersAddError { s.serialize_field(".tag", "group_not_in_team")?; s.end() } - GroupMembersAddError::MembersNotInTeam(ref x) => { + GroupMembersAddError::MembersNotInTeam(x) => { // primitive let mut s = serializer.serialize_struct("GroupMembersAddError", 2)?; s.serialize_field(".tag", "members_not_in_team")?; s.serialize_field("members_not_in_team", x)?; s.end() } - GroupMembersAddError::UsersNotFound(ref x) => { + GroupMembersAddError::UsersNotFound(x) => { // primitive let mut s = serializer.serialize_struct("GroupMembersAddError", 2)?; s.serialize_field(".tag", "users_not_found")?; @@ -5958,7 +5958,7 @@ impl ::serde::ser::Serialize for GroupMembersAddError { s.serialize_field(".tag", "user_must_be_active_to_be_owner")?; s.end() } - GroupMembersAddError::UserCannotBeManagerOfCompanyManagedGroup(ref x) => { + GroupMembersAddError::UserCannotBeManagerOfCompanyManagedGroup(x) => { // primitive let mut s = serializer.serialize_struct("GroupMembersAddError", 2)?; s.serialize_field(".tag", "user_cannot_be_manager_of_company_managed_group")?; @@ -6319,7 +6319,7 @@ impl ::serde::ser::Serialize for GroupMembersRemoveError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupMembersRemoveError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupMembersRemoveError", 1)?; @@ -6344,14 +6344,14 @@ impl ::serde::ser::Serialize for GroupMembersRemoveError { s.serialize_field(".tag", "group_not_in_team")?; s.end() } - GroupMembersRemoveError::MembersNotInTeam(ref x) => { + GroupMembersRemoveError::MembersNotInTeam(x) => { // primitive let mut s = serializer.serialize_struct("GroupMembersRemoveError", 2)?; s.serialize_field(".tag", "members_not_in_team")?; s.serialize_field("members_not_in_team", x)?; s.end() } - GroupMembersRemoveError::UsersNotFound(ref x) => { + GroupMembersRemoveError::UsersNotFound(x) => { // primitive let mut s = serializer.serialize_struct("GroupMembersRemoveError", 2)?; s.serialize_field(".tag", "users_not_found")?; @@ -6549,7 +6549,7 @@ impl ::serde::ser::Serialize for GroupMembersSelectorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupMembersSelectorError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupMembersSelectorError", 1)?; @@ -6800,15 +6800,15 @@ impl ::serde::ser::Serialize for GroupSelector { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GroupSelector::GroupId(ref x) => { + match self { + GroupSelector::GroupId(x) => { // primitive let mut s = serializer.serialize_struct("GroupSelector", 2)?; s.serialize_field(".tag", "group_id")?; s.serialize_field("group_id", x)?; s.end() } - GroupSelector::GroupExternalId(ref x) => { + GroupSelector::GroupExternalId(x) => { // primitive let mut s = serializer.serialize_struct("GroupSelector", 2)?; s.serialize_field(".tag", "group_external_id")?; @@ -6863,7 +6863,7 @@ impl ::serde::ser::Serialize for GroupSelectorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupSelectorError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupSelectorError", 1)?; @@ -6936,7 +6936,7 @@ impl ::serde::ser::Serialize for GroupSelectorWithTeamGroupError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupSelectorWithTeamGroupError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupSelectorWithTeamGroupError", 1)?; @@ -7223,7 +7223,7 @@ impl ::serde::ser::Serialize for GroupUpdateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupUpdateError::GroupNotFound => { // unit let mut s = serializer.serialize_struct("GroupUpdateError", 1)?; @@ -7328,7 +7328,7 @@ impl ::serde::ser::Serialize for GroupsGetInfoError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupsGetInfoError::GroupNotOnTeam => { // unit let mut s = serializer.serialize_struct("GroupsGetInfoError", 1)?; @@ -7402,15 +7402,15 @@ impl ::serde::ser::Serialize for GroupsGetInfoItem { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GroupsGetInfoItem::IdNotFound(ref x) => { + match self { + GroupsGetInfoItem::IdNotFound(x) => { // primitive let mut s = serializer.serialize_struct("GroupsGetInfoItem", 2)?; s.serialize_field(".tag", "id_not_found")?; s.serialize_field("id_not_found", x)?; s.end() } - GroupsGetInfoItem::GroupInfo(ref x) => { + GroupsGetInfoItem::GroupInfo(x) => { // struct let mut s = serializer.serialize_struct("GroupsGetInfoItem", 8)?; s.serialize_field(".tag", "group_info")?; @@ -7644,7 +7644,7 @@ impl ::serde::ser::Serialize for GroupsListContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupsListContinueError::InvalidCursor => { // unit let mut s = serializer.serialize_struct("GroupsListContinueError", 1)?; @@ -8035,7 +8035,7 @@ impl ::serde::ser::Serialize for GroupsMembersListContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupsMembersListContinueError::InvalidCursor => { // unit let mut s = serializer.serialize_struct("GroupsMembersListContinueError", 1)?; @@ -8231,7 +8231,7 @@ impl ::serde::ser::Serialize for GroupsPollError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupsPollError::InvalidAsyncJobId => { // unit let mut s = serializer.serialize_struct("GroupsPollError", 1)?; @@ -8334,15 +8334,15 @@ impl ::serde::ser::Serialize for GroupsSelector { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GroupsSelector::GroupIds(ref x) => { + match self { + GroupsSelector::GroupIds(x) => { // primitive let mut s = serializer.serialize_struct("GroupsSelector", 2)?; s.serialize_field(".tag", "group_ids")?; s.serialize_field("group_ids", x)?; s.end() } - GroupsSelector::GroupExternalIds(ref x) => { + GroupsSelector::GroupExternalIds(x) => { // primitive let mut s = serializer.serialize_struct("GroupsSelector", 2)?; s.serialize_field(".tag", "group_external_ids")?; @@ -8403,8 +8403,8 @@ impl ::serde::ser::Serialize for HasTeamFileEventsValue { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - HasTeamFileEventsValue::Enabled(ref x) => { + match self { + HasTeamFileEventsValue::Enabled(x) => { // primitive let mut s = serializer.serialize_struct("HasTeamFileEventsValue", 2)?; s.serialize_field(".tag", "enabled")?; @@ -8466,8 +8466,8 @@ impl ::serde::ser::Serialize for HasTeamSelectiveSyncValue { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - HasTeamSelectiveSyncValue::HasTeamSelectiveSync(ref x) => { + match self { + HasTeamSelectiveSyncValue::HasTeamSelectiveSync(x) => { // primitive let mut s = serializer.serialize_struct("HasTeamSelectiveSyncValue", 2)?; s.serialize_field(".tag", "has_team_selective_sync")?; @@ -8529,8 +8529,8 @@ impl ::serde::ser::Serialize for HasTeamSharedDropboxValue { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - HasTeamSharedDropboxValue::HasTeamSharedDropbox(ref x) => { + match self { + HasTeamSharedDropboxValue::HasTeamSharedDropbox(x) => { // primitive let mut s = serializer.serialize_struct("HasTeamSharedDropboxValue", 2)?; s.serialize_field(".tag", "has_team_shared_dropbox")?; @@ -9126,7 +9126,7 @@ impl ::serde::ser::Serialize for LegalHoldStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldStatus::Active => { // unit let mut s = serializer.serialize_struct("LegalHoldStatus", 1)?; @@ -9215,7 +9215,7 @@ impl ::serde::ser::Serialize for LegalHoldsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldsError::UnknownLegalHoldError => { // unit let mut s = serializer.serialize_struct("LegalHoldsError", 1)?; @@ -9388,7 +9388,7 @@ impl ::serde::ser::Serialize for LegalHoldsGetPolicyError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldsGetPolicyError::UnknownLegalHoldError => { // unit let mut s = serializer.serialize_struct("LegalHoldsGetPolicyError", 1)?; @@ -9818,7 +9818,7 @@ impl ::serde::ser::Serialize for LegalHoldsListHeldRevisionsContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldsListHeldRevisionsContinueError::UnknownLegalHoldError => { // unit let mut s = serializer.serialize_struct("LegalHoldsListHeldRevisionsContinueError", 1)?; @@ -9914,7 +9914,7 @@ impl ::serde::ser::Serialize for LegalHoldsListHeldRevisionsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldsListHeldRevisionsError::UnknownLegalHoldError => { // unit let mut s = serializer.serialize_struct("LegalHoldsListHeldRevisionsError", 1)?; @@ -10108,7 +10108,7 @@ impl ::serde::ser::Serialize for LegalHoldsListPoliciesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldsListPoliciesError::UnknownLegalHoldError => { // unit let mut s = serializer.serialize_struct("LegalHoldsListPoliciesError", 1)?; @@ -10492,7 +10492,7 @@ impl ::serde::ser::Serialize for LegalHoldsPolicyCreateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldsPolicyCreateError::UnknownLegalHoldError => { // unit let mut s = serializer.serialize_struct("LegalHoldsPolicyCreateError", 1)?; @@ -10740,7 +10740,7 @@ impl ::serde::ser::Serialize for LegalHoldsPolicyReleaseError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldsPolicyReleaseError::UnknownLegalHoldError => { // unit let mut s = serializer.serialize_struct("LegalHoldsPolicyReleaseError", 1)?; @@ -11032,7 +11032,7 @@ impl ::serde::ser::Serialize for LegalHoldsPolicyUpdateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LegalHoldsPolicyUpdateError::UnknownLegalHoldError => { // unit let mut s = serializer.serialize_struct("LegalHoldsPolicyUpdateError", 1)?; @@ -11264,7 +11264,7 @@ impl ::serde::ser::Serialize for ListMemberAppsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListMemberAppsError::MemberNotFound => { // unit let mut s = serializer.serialize_struct("ListMemberAppsError", 1)?; @@ -11573,7 +11573,7 @@ impl ::serde::ser::Serialize for ListMemberDevicesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListMemberDevicesError::MemberNotFound => { // unit let mut s = serializer.serialize_struct("ListMemberDevicesError", 1)?; @@ -11850,7 +11850,7 @@ impl ::serde::ser::Serialize for ListMembersAppsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListMembersAppsError::Reset => { // unit let mut s = serializer.serialize_struct("ListMembersAppsError", 1)?; @@ -12199,7 +12199,7 @@ impl ::serde::ser::Serialize for ListMembersDevicesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListMembersDevicesError::Reset => { // unit let mut s = serializer.serialize_struct("ListMembersDevicesError", 1)?; @@ -12482,7 +12482,7 @@ impl ::serde::ser::Serialize for ListTeamAppsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListTeamAppsError::Reset => { // unit let mut s = serializer.serialize_struct("ListTeamAppsError", 1)?; @@ -12830,7 +12830,7 @@ impl ::serde::ser::Serialize for ListTeamDevicesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ListTeamDevicesError::Reset => { // unit let mut s = serializer.serialize_struct("ListTeamDevicesError", 1)?; @@ -13700,78 +13700,78 @@ impl ::serde::ser::Serialize for MemberAddResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MemberAddResult::TeamLicenseLimit(ref x) => { + match self { + MemberAddResult::TeamLicenseLimit(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "team_license_limit")?; s.serialize_field("team_license_limit", x)?; s.end() } - MemberAddResult::FreeTeamMemberLimitReached(ref x) => { + MemberAddResult::FreeTeamMemberLimitReached(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "free_team_member_limit_reached")?; s.serialize_field("free_team_member_limit_reached", x)?; s.end() } - MemberAddResult::UserAlreadyOnTeam(ref x) => { + MemberAddResult::UserAlreadyOnTeam(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "user_already_on_team")?; s.serialize_field("user_already_on_team", x)?; s.end() } - MemberAddResult::UserOnAnotherTeam(ref x) => { + MemberAddResult::UserOnAnotherTeam(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "user_on_another_team")?; s.serialize_field("user_on_another_team", x)?; s.end() } - MemberAddResult::UserAlreadyPaired(ref x) => { + MemberAddResult::UserAlreadyPaired(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "user_already_paired")?; s.serialize_field("user_already_paired", x)?; s.end() } - MemberAddResult::UserMigrationFailed(ref x) => { + MemberAddResult::UserMigrationFailed(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "user_migration_failed")?; s.serialize_field("user_migration_failed", x)?; s.end() } - MemberAddResult::DuplicateExternalMemberId(ref x) => { + MemberAddResult::DuplicateExternalMemberId(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "duplicate_external_member_id")?; s.serialize_field("duplicate_external_member_id", x)?; s.end() } - MemberAddResult::DuplicateMemberPersistentId(ref x) => { + MemberAddResult::DuplicateMemberPersistentId(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "duplicate_member_persistent_id")?; s.serialize_field("duplicate_member_persistent_id", x)?; s.end() } - MemberAddResult::PersistentIdDisabled(ref x) => { + MemberAddResult::PersistentIdDisabled(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "persistent_id_disabled")?; s.serialize_field("persistent_id_disabled", x)?; s.end() } - MemberAddResult::UserCreationFailed(ref x) => { + MemberAddResult::UserCreationFailed(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResult", 2)?; s.serialize_field(".tag", "user_creation_failed")?; s.serialize_field("user_creation_failed", x)?; s.end() } - MemberAddResult::Success(ref x) => { + MemberAddResult::Success(x) => { // struct let mut s = serializer.serialize_struct("MemberAddResult", 3)?; s.serialize_field(".tag", "success")?; @@ -13938,71 +13938,71 @@ impl ::serde::ser::Serialize for MemberAddResultBase { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MemberAddResultBase::TeamLicenseLimit(ref x) => { + match self { + MemberAddResultBase::TeamLicenseLimit(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "team_license_limit")?; s.serialize_field("team_license_limit", x)?; s.end() } - MemberAddResultBase::FreeTeamMemberLimitReached(ref x) => { + MemberAddResultBase::FreeTeamMemberLimitReached(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "free_team_member_limit_reached")?; s.serialize_field("free_team_member_limit_reached", x)?; s.end() } - MemberAddResultBase::UserAlreadyOnTeam(ref x) => { + MemberAddResultBase::UserAlreadyOnTeam(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "user_already_on_team")?; s.serialize_field("user_already_on_team", x)?; s.end() } - MemberAddResultBase::UserOnAnotherTeam(ref x) => { + MemberAddResultBase::UserOnAnotherTeam(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "user_on_another_team")?; s.serialize_field("user_on_another_team", x)?; s.end() } - MemberAddResultBase::UserAlreadyPaired(ref x) => { + MemberAddResultBase::UserAlreadyPaired(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "user_already_paired")?; s.serialize_field("user_already_paired", x)?; s.end() } - MemberAddResultBase::UserMigrationFailed(ref x) => { + MemberAddResultBase::UserMigrationFailed(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "user_migration_failed")?; s.serialize_field("user_migration_failed", x)?; s.end() } - MemberAddResultBase::DuplicateExternalMemberId(ref x) => { + MemberAddResultBase::DuplicateExternalMemberId(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "duplicate_external_member_id")?; s.serialize_field("duplicate_external_member_id", x)?; s.end() } - MemberAddResultBase::DuplicateMemberPersistentId(ref x) => { + MemberAddResultBase::DuplicateMemberPersistentId(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "duplicate_member_persistent_id")?; s.serialize_field("duplicate_member_persistent_id", x)?; s.end() } - MemberAddResultBase::PersistentIdDisabled(ref x) => { + MemberAddResultBase::PersistentIdDisabled(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "persistent_id_disabled")?; s.serialize_field("persistent_id_disabled", x)?; s.end() } - MemberAddResultBase::UserCreationFailed(ref x) => { + MemberAddResultBase::UserCreationFailed(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddResultBase", 2)?; s.serialize_field(".tag", "user_creation_failed")?; @@ -14416,78 +14416,78 @@ impl ::serde::ser::Serialize for MemberAddV2Result { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MemberAddV2Result::TeamLicenseLimit(ref x) => { + match self { + MemberAddV2Result::TeamLicenseLimit(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "team_license_limit")?; s.serialize_field("team_license_limit", x)?; s.end() } - MemberAddV2Result::FreeTeamMemberLimitReached(ref x) => { + MemberAddV2Result::FreeTeamMemberLimitReached(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "free_team_member_limit_reached")?; s.serialize_field("free_team_member_limit_reached", x)?; s.end() } - MemberAddV2Result::UserAlreadyOnTeam(ref x) => { + MemberAddV2Result::UserAlreadyOnTeam(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "user_already_on_team")?; s.serialize_field("user_already_on_team", x)?; s.end() } - MemberAddV2Result::UserOnAnotherTeam(ref x) => { + MemberAddV2Result::UserOnAnotherTeam(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "user_on_another_team")?; s.serialize_field("user_on_another_team", x)?; s.end() } - MemberAddV2Result::UserAlreadyPaired(ref x) => { + MemberAddV2Result::UserAlreadyPaired(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "user_already_paired")?; s.serialize_field("user_already_paired", x)?; s.end() } - MemberAddV2Result::UserMigrationFailed(ref x) => { + MemberAddV2Result::UserMigrationFailed(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "user_migration_failed")?; s.serialize_field("user_migration_failed", x)?; s.end() } - MemberAddV2Result::DuplicateExternalMemberId(ref x) => { + MemberAddV2Result::DuplicateExternalMemberId(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "duplicate_external_member_id")?; s.serialize_field("duplicate_external_member_id", x)?; s.end() } - MemberAddV2Result::DuplicateMemberPersistentId(ref x) => { + MemberAddV2Result::DuplicateMemberPersistentId(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "duplicate_member_persistent_id")?; s.serialize_field("duplicate_member_persistent_id", x)?; s.end() } - MemberAddV2Result::PersistentIdDisabled(ref x) => { + MemberAddV2Result::PersistentIdDisabled(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "persistent_id_disabled")?; s.serialize_field("persistent_id_disabled", x)?; s.end() } - MemberAddV2Result::UserCreationFailed(ref x) => { + MemberAddV2Result::UserCreationFailed(x) => { // primitive let mut s = serializer.serialize_struct("MemberAddV2Result", 2)?; s.serialize_field(".tag", "user_creation_failed")?; s.serialize_field("user_creation_failed", x)?; s.end() } - MemberAddV2Result::Success(ref x) => { + MemberAddV2Result::Success(x) => { // struct let mut s = serializer.serialize_struct("MemberAddV2Result", 3)?; s.serialize_field(".tag", "success")?; @@ -15168,7 +15168,7 @@ impl ::serde::ser::Serialize for MemberSelectorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberSelectorError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MemberSelectorError", 1)?; @@ -15465,21 +15465,21 @@ impl ::serde::ser::Serialize for MembersAddJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersAddJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("MembersAddJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - MembersAddJobStatus::Complete(ref x) => { + MembersAddJobStatus::Complete(x) => { // primitive let mut s = serializer.serialize_struct("MembersAddJobStatus", 2)?; s.serialize_field(".tag", "complete")?; s.serialize_field("complete", x)?; s.end() } - MembersAddJobStatus::Failed(ref x) => { + MembersAddJobStatus::Failed(x) => { // primitive let mut s = serializer.serialize_struct("MembersAddJobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -15563,21 +15563,21 @@ impl ::serde::ser::Serialize for MembersAddJobStatusV2Result { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersAddJobStatusV2Result::InProgress => { // unit let mut s = serializer.serialize_struct("MembersAddJobStatusV2Result", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - MembersAddJobStatusV2Result::Complete(ref x) => { + MembersAddJobStatusV2Result::Complete(x) => { // primitive let mut s = serializer.serialize_struct("MembersAddJobStatusV2Result", 2)?; s.serialize_field(".tag", "complete")?; s.serialize_field("complete", x)?; s.end() } - MembersAddJobStatusV2Result::Failed(ref x) => { + MembersAddJobStatusV2Result::Failed(x) => { // primitive let mut s = serializer.serialize_struct("MembersAddJobStatusV2Result", 2)?; s.serialize_field(".tag", "failed")?; @@ -15651,15 +15651,15 @@ impl ::serde::ser::Serialize for MembersAddLaunch { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MembersAddLaunch::AsyncJobId(ref x) => { + match self { + MembersAddLaunch::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("MembersAddLaunch", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - MembersAddLaunch::Complete(ref x) => { + MembersAddLaunch::Complete(x) => { // primitive let mut s = serializer.serialize_struct("MembersAddLaunch", 2)?; s.serialize_field(".tag", "complete")?; @@ -15737,15 +15737,15 @@ impl ::serde::ser::Serialize for MembersAddLaunchV2Result { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MembersAddLaunchV2Result::AsyncJobId(ref x) => { + match self { + MembersAddLaunchV2Result::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("MembersAddLaunchV2Result", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - MembersAddLaunchV2Result::Complete(ref x) => { + MembersAddLaunchV2Result::Complete(x) => { // primitive let mut s = serializer.serialize_struct("MembersAddLaunchV2Result", 2)?; s.serialize_field(".tag", "complete")?; @@ -16273,7 +16273,7 @@ impl ::serde::ser::Serialize for MembersDeactivateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersDeactivateError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersDeactivateError", 1)?; @@ -16455,7 +16455,7 @@ impl ::serde::ser::Serialize for MembersDeleteProfilePhotoError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersDeleteProfilePhotoError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersDeleteProfilePhotoError", 1)?; @@ -16792,15 +16792,15 @@ impl ::serde::ser::Serialize for MembersGetInfoItem { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MembersGetInfoItem::IdNotFound(ref x) => { + match self { + MembersGetInfoItem::IdNotFound(x) => { // primitive let mut s = serializer.serialize_struct("MembersGetInfoItem", 2)?; s.serialize_field(".tag", "id_not_found")?; s.serialize_field("id_not_found", x)?; s.end() } - MembersGetInfoItem::MemberInfo(ref x) => { + MembersGetInfoItem::MemberInfo(x) => { // struct let mut s = serializer.serialize_struct("MembersGetInfoItem", 3)?; s.serialize_field(".tag", "member_info")?; @@ -16867,8 +16867,8 @@ impl ::serde::ser::Serialize for MembersGetInfoItemBase { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MembersGetInfoItemBase::IdNotFound(ref x) => { + match self { + MembersGetInfoItemBase::IdNotFound(x) => { // primitive let mut s = serializer.serialize_struct("MembersGetInfoItemBase", 2)?; s.serialize_field(".tag", "id_not_found")?; @@ -16938,15 +16938,15 @@ impl ::serde::ser::Serialize for MembersGetInfoItemV2 { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - MembersGetInfoItemV2::IdNotFound(ref x) => { + match self { + MembersGetInfoItemV2::IdNotFound(x) => { // primitive let mut s = serializer.serialize_struct("MembersGetInfoItemV2", 2)?; s.serialize_field(".tag", "id_not_found")?; s.serialize_field("id_not_found", x)?; s.end() } - MembersGetInfoItemV2::MemberInfo(ref x) => { + MembersGetInfoItemV2::MemberInfo(x) => { // struct let mut s = serializer.serialize_struct("MembersGetInfoItemV2", 3)?; s.serialize_field(".tag", "member_info")?; @@ -17498,7 +17498,7 @@ impl ::serde::ser::Serialize for MembersListContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersListContinueError::InvalidCursor => { // unit let mut s = serializer.serialize_struct("MembersListContinueError", 1)?; @@ -17962,7 +17962,7 @@ impl ::serde::ser::Serialize for MembersRecoverError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersRecoverError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersRecoverError", 1)?; @@ -18356,7 +18356,7 @@ impl ::serde::ser::Serialize for MembersRemoveError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersRemoveError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersRemoveError", 1)?; @@ -18592,7 +18592,7 @@ impl ::serde::ser::Serialize for MembersSendWelcomeError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersSendWelcomeError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersSendWelcomeError", 1)?; @@ -18806,7 +18806,7 @@ impl ::serde::ser::Serialize for MembersSetPermissions2Error { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersSetPermissions2Error::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersSetPermissions2Error", 1)?; @@ -19143,7 +19143,7 @@ impl ::serde::ser::Serialize for MembersSetPermissionsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersSetPermissionsError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersSetPermissionsError", 1)?; @@ -19610,7 +19610,7 @@ impl ::serde::ser::Serialize for MembersSetProfileError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersSetProfileError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersSetProfileError", 1)?; @@ -19878,7 +19878,7 @@ impl ::serde::ser::Serialize for MembersSetProfilePhotoError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersSetProfilePhotoError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersSetProfilePhotoError", 1)?; @@ -19897,7 +19897,7 @@ impl ::serde::ser::Serialize for MembersSetProfilePhotoError { s.serialize_field(".tag", "set_profile_disallowed")?; s.end() } - MembersSetProfilePhotoError::PhotoError(ref x) => { + MembersSetProfilePhotoError::PhotoError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("MembersSetProfilePhotoError", 2)?; s.serialize_field(".tag", "photo_error")?; @@ -19999,7 +19999,7 @@ impl ::serde::ser::Serialize for MembersSuspendError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersSuspendError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersSuspendError", 1)?; @@ -20145,7 +20145,7 @@ impl ::serde::ser::Serialize for MembersTransferFilesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersTransferFilesError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersTransferFilesError", 1)?; @@ -20349,7 +20349,7 @@ impl ::serde::ser::Serialize for MembersTransferFormerMembersFilesError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersTransferFormerMembersFilesError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersTransferFormerMembersFilesError", 1)?; @@ -20639,7 +20639,7 @@ impl ::serde::ser::Serialize for MembersUnsuspendError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MembersUnsuspendError::UserNotFound => { // unit let mut s = serializer.serialize_struct("MembersUnsuspendError", 1)?; @@ -20753,7 +20753,7 @@ impl ::serde::ser::Serialize for MobileClientPlatform { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MobileClientPlatform::Iphone => { // unit let mut s = serializer.serialize_struct("MobileClientPlatform", 1)?; @@ -21261,7 +21261,7 @@ impl ::serde::ser::Serialize for NamespaceType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { NamespaceType::AppFolder => { // unit let mut s = serializer.serialize_struct("NamespaceType", 1)?; @@ -21351,15 +21351,15 @@ impl ::serde::ser::Serialize for RemoveCustomQuotaResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RemoveCustomQuotaResult::Success(ref x) => { + match self { + RemoveCustomQuotaResult::Success(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemoveCustomQuotaResult", 2)?; s.serialize_field(".tag", "success")?; s.serialize_field("success", x)?; s.end() } - RemoveCustomQuotaResult::InvalidUser(ref x) => { + RemoveCustomQuotaResult::InvalidUser(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("RemoveCustomQuotaResult", 2)?; s.serialize_field(".tag", "invalid_user")?; @@ -21547,22 +21547,22 @@ impl ::serde::ser::Serialize for ResendSecondaryEmailResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ResendSecondaryEmailResult::Success(ref x) => { + match self { + ResendSecondaryEmailResult::Success(x) => { // primitive let mut s = serializer.serialize_struct("ResendSecondaryEmailResult", 2)?; s.serialize_field(".tag", "success")?; s.serialize_field("success", x)?; s.end() } - ResendSecondaryEmailResult::NotPending(ref x) => { + ResendSecondaryEmailResult::NotPending(x) => { // primitive let mut s = serializer.serialize_struct("ResendSecondaryEmailResult", 2)?; s.serialize_field(".tag", "not_pending")?; s.serialize_field("not_pending", x)?; s.end() } - ResendSecondaryEmailResult::RateLimited(ref x) => { + ResendSecondaryEmailResult::RateLimited(x) => { // primitive let mut s = serializer.serialize_struct("ResendSecondaryEmailResult", 2)?; s.serialize_field(".tag", "rate_limited")?; @@ -21936,22 +21936,22 @@ impl ::serde::ser::Serialize for RevokeDeviceSessionArg { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - RevokeDeviceSessionArg::WebSession(ref x) => { + match self { + RevokeDeviceSessionArg::WebSession(x) => { // struct let mut s = serializer.serialize_struct("RevokeDeviceSessionArg", 3)?; s.serialize_field(".tag", "web_session")?; x.internal_serialize::(&mut s)?; s.end() } - RevokeDeviceSessionArg::DesktopClient(ref x) => { + RevokeDeviceSessionArg::DesktopClient(x) => { // struct let mut s = serializer.serialize_struct("RevokeDeviceSessionArg", 4)?; s.serialize_field(".tag", "desktop_client")?; x.internal_serialize::(&mut s)?; s.end() } - RevokeDeviceSessionArg::MobileClient(ref x) => { + RevokeDeviceSessionArg::MobileClient(x) => { // struct let mut s = serializer.serialize_struct("RevokeDeviceSessionArg", 3)?; s.serialize_field(".tag", "mobile_client")?; @@ -22241,7 +22241,7 @@ impl ::serde::ser::Serialize for RevokeDeviceSessionError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RevokeDeviceSessionError::DeviceSessionNotFound => { // unit let mut s = serializer.serialize_struct("RevokeDeviceSessionError", 1)?; @@ -22794,7 +22794,7 @@ impl ::serde::ser::Serialize for RevokeLinkedAppError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RevokeLinkedAppError::AppNotFound => { // unit let mut s = serializer.serialize_struct("RevokeLinkedAppError", 1)?; @@ -23082,7 +23082,7 @@ impl ::serde::ser::Serialize for SetCustomQuotaError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SetCustomQuotaError::TooManyUsers => { // unit let mut s = serializer.serialize_struct("SetCustomQuotaError", 1)?; @@ -23299,8 +23299,8 @@ impl ::serde::ser::Serialize for SharingAllowlistAddError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SharingAllowlistAddError::MalformedEntry(ref x) => { + match self { + SharingAllowlistAddError::MalformedEntry(x) => { // primitive let mut s = serializer.serialize_struct("SharingAllowlistAddError", 2)?; s.serialize_field(".tag", "malformed_entry")?; @@ -23331,7 +23331,7 @@ impl ::serde::ser::Serialize for SharingAllowlistAddError { s.serialize_field(".tag", "unknown_error")?; s.end() } - SharingAllowlistAddError::EntriesAlreadyExist(ref x) => { + SharingAllowlistAddError::EntriesAlreadyExist(x) => { // primitive let mut s = serializer.serialize_struct("SharingAllowlistAddError", 2)?; s.serialize_field(".tag", "entries_already_exist")?; @@ -23630,7 +23630,7 @@ impl ::serde::ser::Serialize for SharingAllowlistListContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharingAllowlistListContinueError::InvalidCursor => { // unit let mut s = serializer.serialize_struct("SharingAllowlistListContinueError", 1)?; @@ -24025,15 +24025,15 @@ impl ::serde::ser::Serialize for SharingAllowlistRemoveError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SharingAllowlistRemoveError::MalformedEntry(ref x) => { + match self { + SharingAllowlistRemoveError::MalformedEntry(x) => { // primitive let mut s = serializer.serialize_struct("SharingAllowlistRemoveError", 2)?; s.serialize_field(".tag", "malformed_entry")?; s.serialize_field("malformed_entry", x)?; s.end() } - SharingAllowlistRemoveError::EntriesDoNotExist(ref x) => { + SharingAllowlistRemoveError::EntriesDoNotExist(x) => { // primitive let mut s = serializer.serialize_struct("SharingAllowlistRemoveError", 2)?; s.serialize_field(".tag", "entries_do_not_exist")?; @@ -24277,7 +24277,7 @@ impl ::serde::ser::Serialize for TeamFolderAccessError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamFolderAccessError::InvalidTeamFolderId => { // unit let mut s = serializer.serialize_struct("TeamFolderAccessError", 1)?; @@ -24375,22 +24375,22 @@ impl ::serde::ser::Serialize for TeamFolderActivateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamFolderActivateError::AccessError(ref x) => { + match self { + TeamFolderActivateError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderActivateError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - TeamFolderActivateError::StatusError(ref x) => { + TeamFolderActivateError::StatusError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderActivateError", 2)?; s.serialize_field(".tag", "status_error")?; s.serialize_field("status_error", x)?; s.end() } - TeamFolderActivateError::TeamSharedDropboxError(ref x) => { + TeamFolderActivateError::TeamSharedDropboxError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderActivateError", 2)?; s.serialize_field(".tag", "team_shared_dropbox_error")?; @@ -24621,22 +24621,22 @@ impl ::serde::ser::Serialize for TeamFolderArchiveError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamFolderArchiveError::AccessError(ref x) => { + match self { + TeamFolderArchiveError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderArchiveError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - TeamFolderArchiveError::StatusError(ref x) => { + TeamFolderArchiveError::StatusError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderArchiveError", 2)?; s.serialize_field(".tag", "status_error")?; s.serialize_field("status_error", x)?; s.end() } - TeamFolderArchiveError::TeamSharedDropboxError(ref x) => { + TeamFolderArchiveError::TeamSharedDropboxError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderArchiveError", 2)?; s.serialize_field(".tag", "team_shared_dropbox_error")?; @@ -24734,21 +24734,21 @@ impl ::serde::ser::Serialize for TeamFolderArchiveJobStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamFolderArchiveJobStatus::InProgress => { // unit let mut s = serializer.serialize_struct("TeamFolderArchiveJobStatus", 1)?; s.serialize_field(".tag", "in_progress")?; s.end() } - TeamFolderArchiveJobStatus::Complete(ref x) => { + TeamFolderArchiveJobStatus::Complete(x) => { // struct let mut s = serializer.serialize_struct("TeamFolderArchiveJobStatus", 7)?; s.serialize_field(".tag", "complete")?; x.internal_serialize::(&mut s)?; s.end() } - TeamFolderArchiveJobStatus::Failed(ref x) => { + TeamFolderArchiveJobStatus::Failed(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderArchiveJobStatus", 2)?; s.serialize_field(".tag", "failed")?; @@ -24815,15 +24815,15 @@ impl ::serde::ser::Serialize for TeamFolderArchiveLaunch { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamFolderArchiveLaunch::AsyncJobId(ref x) => { + match self { + TeamFolderArchiveLaunch::AsyncJobId(x) => { // primitive let mut s = serializer.serialize_struct("TeamFolderArchiveLaunch", 2)?; s.serialize_field(".tag", "async_job_id")?; s.serialize_field("async_job_id", x)?; s.end() } - TeamFolderArchiveLaunch::Complete(ref x) => { + TeamFolderArchiveLaunch::Complete(x) => { // struct let mut s = serializer.serialize_struct("TeamFolderArchiveLaunch", 7)?; s.serialize_field(".tag", "complete")?; @@ -25015,7 +25015,7 @@ impl ::serde::ser::Serialize for TeamFolderCreateError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamFolderCreateError::InvalidFolderName => { // unit let mut s = serializer.serialize_struct("TeamFolderCreateError", 1)?; @@ -25034,7 +25034,7 @@ impl ::serde::ser::Serialize for TeamFolderCreateError { s.serialize_field(".tag", "folder_name_reserved")?; s.end() } - TeamFolderCreateError::SyncSettingsError(ref x) => { + TeamFolderCreateError::SyncSettingsError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderCreateError", 2)?; s.serialize_field(".tag", "sync_settings_error")?; @@ -25117,15 +25117,15 @@ impl ::serde::ser::Serialize for TeamFolderGetInfoItem { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamFolderGetInfoItem::IdNotFound(ref x) => { + match self { + TeamFolderGetInfoItem::IdNotFound(x) => { // primitive let mut s = serializer.serialize_struct("TeamFolderGetInfoItem", 2)?; s.serialize_field(".tag", "id_not_found")?; s.serialize_field("id_not_found", x)?; s.end() } - TeamFolderGetInfoItem::TeamFolderMetadata(ref x) => { + TeamFolderGetInfoItem::TeamFolderMetadata(x) => { // struct let mut s = serializer.serialize_struct("TeamFolderGetInfoItem", 7)?; s.serialize_field(".tag", "team_folder_metadata")?; @@ -25369,7 +25369,7 @@ impl ::serde::ser::Serialize for TeamFolderInvalidStatusError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamFolderInvalidStatusError::Active => { // unit let mut s = serializer.serialize_struct("TeamFolderInvalidStatusError", 1)?; @@ -25630,7 +25630,7 @@ impl ::serde::ser::Serialize for TeamFolderListContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamFolderListContinueError::InvalidCursor => { // unit let mut s = serializer.serialize_struct("TeamFolderListContinueError", 1)?; @@ -26106,22 +26106,22 @@ impl ::serde::ser::Serialize for TeamFolderPermanentlyDeleteError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamFolderPermanentlyDeleteError::AccessError(ref x) => { + match self { + TeamFolderPermanentlyDeleteError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderPermanentlyDeleteError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - TeamFolderPermanentlyDeleteError::StatusError(ref x) => { + TeamFolderPermanentlyDeleteError::StatusError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderPermanentlyDeleteError", 2)?; s.serialize_field(".tag", "status_error")?; s.serialize_field("status_error", x)?; s.end() } - TeamFolderPermanentlyDeleteError::TeamSharedDropboxError(ref x) => { + TeamFolderPermanentlyDeleteError::TeamSharedDropboxError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderPermanentlyDeleteError", 2)?; s.serialize_field(".tag", "team_shared_dropbox_error")?; @@ -26356,22 +26356,22 @@ impl ::serde::ser::Serialize for TeamFolderRenameError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamFolderRenameError::AccessError(ref x) => { + match self { + TeamFolderRenameError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderRenameError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - TeamFolderRenameError::StatusError(ref x) => { + TeamFolderRenameError::StatusError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderRenameError", 2)?; s.serialize_field(".tag", "status_error")?; s.serialize_field("status_error", x)?; s.end() } - TeamFolderRenameError::TeamSharedDropboxError(ref x) => { + TeamFolderRenameError::TeamSharedDropboxError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderRenameError", 2)?; s.serialize_field(".tag", "team_shared_dropbox_error")?; @@ -26488,7 +26488,7 @@ impl ::serde::ser::Serialize for TeamFolderStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamFolderStatus::Active => { // unit let mut s = serializer.serialize_struct("TeamFolderStatus", 1)?; @@ -26555,7 +26555,7 @@ impl ::serde::ser::Serialize for TeamFolderTeamSharedDropboxError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamFolderTeamSharedDropboxError::Disallowed => { // unit let mut s = serializer.serialize_struct("TeamFolderTeamSharedDropboxError", 1)?; @@ -26798,29 +26798,29 @@ impl ::serde::ser::Serialize for TeamFolderUpdateSyncSettingsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamFolderUpdateSyncSettingsError::AccessError(ref x) => { + match self { + TeamFolderUpdateSyncSettingsError::AccessError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderUpdateSyncSettingsError", 2)?; s.serialize_field(".tag", "access_error")?; s.serialize_field("access_error", x)?; s.end() } - TeamFolderUpdateSyncSettingsError::StatusError(ref x) => { + TeamFolderUpdateSyncSettingsError::StatusError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderUpdateSyncSettingsError", 2)?; s.serialize_field(".tag", "status_error")?; s.serialize_field("status_error", x)?; s.end() } - TeamFolderUpdateSyncSettingsError::TeamSharedDropboxError(ref x) => { + TeamFolderUpdateSyncSettingsError::TeamSharedDropboxError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderUpdateSyncSettingsError", 2)?; s.serialize_field(".tag", "team_shared_dropbox_error")?; s.serialize_field("team_shared_dropbox_error", x)?; s.end() } - TeamFolderUpdateSyncSettingsError::SyncSettingsError(ref x) => { + TeamFolderUpdateSyncSettingsError::SyncSettingsError(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("TeamFolderUpdateSyncSettingsError", 2)?; s.serialize_field(".tag", "sync_settings_error")?; @@ -27920,7 +27920,7 @@ impl ::serde::ser::Serialize for TeamMemberStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamMemberStatus::Active => { // unit let mut s = serializer.serialize_struct("TeamMemberStatus", 1)?; @@ -27939,7 +27939,7 @@ impl ::serde::ser::Serialize for TeamMemberStatus { s.serialize_field(".tag", "suspended")?; s.end() } - TeamMemberStatus::Removed(ref x) => { + TeamMemberStatus::Removed(x) => { // struct let mut s = serializer.serialize_struct("TeamMemberStatus", 3)?; s.serialize_field(".tag", "removed")?; @@ -27993,7 +27993,7 @@ impl ::serde::ser::Serialize for TeamMembershipType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamMembershipType::Full => { // unit let mut s = serializer.serialize_struct("TeamMembershipType", 1)?; @@ -28237,7 +28237,7 @@ impl ::serde::ser::Serialize for TeamNamespacesListContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamNamespacesListContinueError::InvalidArg => { // unit let mut s = serializer.serialize_struct("TeamNamespacesListContinueError", 1)?; @@ -28320,7 +28320,7 @@ impl ::serde::ser::Serialize for TeamNamespacesListError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamNamespacesListError::InvalidArg => { // unit let mut s = serializer.serialize_struct("TeamNamespacesListError", 1)?; @@ -28516,7 +28516,7 @@ impl ::serde::ser::Serialize for TeamReportFailureReason { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamReportFailureReason::TemporaryError => { // unit let mut s = serializer.serialize_struct("TeamReportFailureReason", 1)?; @@ -28592,7 +28592,7 @@ impl ::serde::ser::Serialize for TokenGetAuthenticatedAdminError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TokenGetAuthenticatedAdminError::MappingNotFound => { // unit let mut s = serializer.serialize_struct("TokenGetAuthenticatedAdminError", 1)?; @@ -28770,14 +28770,14 @@ impl ::serde::ser::Serialize for UploadApiRateLimitValue { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UploadApiRateLimitValue::Unlimited => { // unit let mut s = serializer.serialize_struct("UploadApiRateLimitValue", 1)?; s.serialize_field(".tag", "unlimited")?; s.end() } - UploadApiRateLimitValue::Limit(ref x) => { + UploadApiRateLimitValue::Limit(x) => { // primitive let mut s = serializer.serialize_struct("UploadApiRateLimitValue", 2)?; s.serialize_field(".tag", "limit")?; @@ -28865,29 +28865,29 @@ impl ::serde::ser::Serialize for UserAddResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UserAddResult::Success(ref x) => { + match self { + UserAddResult::Success(x) => { // struct let mut s = serializer.serialize_struct("UserAddResult", 3)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - UserAddResult::InvalidUser(ref x) => { + UserAddResult::InvalidUser(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UserAddResult", 2)?; s.serialize_field(".tag", "invalid_user")?; s.serialize_field("invalid_user", x)?; s.end() } - UserAddResult::Unverified(ref x) => { + UserAddResult::Unverified(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UserAddResult", 2)?; s.serialize_field(".tag", "unverified")?; s.serialize_field("unverified", x)?; s.end() } - UserAddResult::PlaceholderUser(ref x) => { + UserAddResult::PlaceholderUser(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UserAddResult", 2)?; s.serialize_field(".tag", "placeholder_user")?; @@ -29271,15 +29271,15 @@ impl ::serde::ser::Serialize for UserDeleteResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UserDeleteResult::Success(ref x) => { + match self { + UserDeleteResult::Success(x) => { // struct let mut s = serializer.serialize_struct("UserDeleteResult", 3)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - UserDeleteResult::InvalidUser(ref x) => { + UserDeleteResult::InvalidUser(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UserDeleteResult", 2)?; s.serialize_field(".tag", "invalid_user")?; @@ -29449,15 +29449,15 @@ impl ::serde::ser::Serialize for UserResendResult { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UserResendResult::Success(ref x) => { + match self { + UserResendResult::Success(x) => { // struct let mut s = serializer.serialize_struct("UserResendResult", 3)?; s.serialize_field(".tag", "success")?; x.internal_serialize::(&mut s)?; s.end() } - UserResendResult::InvalidUser(ref x) => { + UserResendResult::InvalidUser(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UserResendResult", 2)?; s.serialize_field(".tag", "invalid_user")?; @@ -29739,22 +29739,22 @@ impl ::serde::ser::Serialize for UserSelectorArg { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UserSelectorArg::TeamMemberId(ref x) => { + match self { + UserSelectorArg::TeamMemberId(x) => { // primitive let mut s = serializer.serialize_struct("UserSelectorArg", 2)?; s.serialize_field(".tag", "team_member_id")?; s.serialize_field("team_member_id", x)?; s.end() } - UserSelectorArg::ExternalId(ref x) => { + UserSelectorArg::ExternalId(x) => { // primitive let mut s = serializer.serialize_struct("UserSelectorArg", 2)?; s.serialize_field(".tag", "external_id")?; s.serialize_field("external_id", x)?; s.end() } - UserSelectorArg::Email(ref x) => { + UserSelectorArg::Email(x) => { // primitive let mut s = serializer.serialize_struct("UserSelectorArg", 2)?; s.serialize_field(".tag", "email")?; @@ -29805,7 +29805,7 @@ impl ::serde::ser::Serialize for UserSelectorError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UserSelectorError::UserNotFound => { // unit let mut s = serializer.serialize_struct("UserSelectorError", 1)?; @@ -29892,22 +29892,22 @@ impl ::serde::ser::Serialize for UsersSelectorArg { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UsersSelectorArg::TeamMemberIds(ref x) => { + match self { + UsersSelectorArg::TeamMemberIds(x) => { // primitive let mut s = serializer.serialize_struct("UsersSelectorArg", 2)?; s.serialize_field(".tag", "team_member_ids")?; s.serialize_field("team_member_ids", x)?; s.end() } - UsersSelectorArg::ExternalIds(ref x) => { + UsersSelectorArg::ExternalIds(x) => { // primitive let mut s = serializer.serialize_struct("UsersSelectorArg", 2)?; s.serialize_field(".tag", "external_ids")?; s.serialize_field("external_ids", x)?; s.end() } - UsersSelectorArg::Emails(ref x) => { + UsersSelectorArg::Emails(x) => { // primitive let mut s = serializer.serialize_struct("UsersSelectorArg", 2)?; s.serialize_field(".tag", "emails")?; diff --git a/src/generated/types/team_common.rs b/src/generated/types/team_common.rs index fedc696..5c6138b 100644 --- a/src/generated/types/team_common.rs +++ b/src/generated/types/team_common.rs @@ -67,7 +67,7 @@ impl ::serde::ser::Serialize for GroupManagementType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupManagementType::UserManaged => { // unit let mut s = serializer.serialize_struct("GroupManagementType", 1)?; @@ -300,7 +300,7 @@ impl ::serde::ser::Serialize for GroupType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupType::Team => { // unit let mut s = serializer.serialize_struct("GroupType", 1)?; @@ -372,7 +372,7 @@ impl ::serde::ser::Serialize for MemberSpaceLimitType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberSpaceLimitType::Off => { // unit let mut s = serializer.serialize_struct("MemberSpaceLimitType", 1)?; diff --git a/src/generated/types/team_log.rs b/src/generated/types/team_log.rs index a2fe465..89dab83 100644 --- a/src/generated/types/team_log.rs +++ b/src/generated/types/team_log.rs @@ -86,43 +86,43 @@ impl ::serde::ser::Serialize for AccessMethodLogInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AccessMethodLogInfo::AdminConsole(ref x) => { + match self { + AccessMethodLogInfo::AdminConsole(x) => { // struct let mut s = serializer.serialize_struct("AccessMethodLogInfo", 2)?; s.serialize_field(".tag", "admin_console")?; x.internal_serialize::(&mut s)?; s.end() } - AccessMethodLogInfo::Api(ref x) => { + AccessMethodLogInfo::Api(x) => { // struct let mut s = serializer.serialize_struct("AccessMethodLogInfo", 2)?; s.serialize_field(".tag", "api")?; x.internal_serialize::(&mut s)?; s.end() } - AccessMethodLogInfo::ContentManager(ref x) => { + AccessMethodLogInfo::ContentManager(x) => { // struct let mut s = serializer.serialize_struct("AccessMethodLogInfo", 2)?; s.serialize_field(".tag", "content_manager")?; x.internal_serialize::(&mut s)?; s.end() } - AccessMethodLogInfo::EndUser(ref x) => { + AccessMethodLogInfo::EndUser(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("AccessMethodLogInfo", 2)?; s.serialize_field(".tag", "end_user")?; s.serialize_field("end_user", x)?; s.end() } - AccessMethodLogInfo::EnterpriseConsole(ref x) => { + AccessMethodLogInfo::EnterpriseConsole(x) => { // struct let mut s = serializer.serialize_struct("AccessMethodLogInfo", 2)?; s.serialize_field(".tag", "enterprise_console")?; x.internal_serialize::(&mut s)?; s.end() } - AccessMethodLogInfo::SignInAs(ref x) => { + AccessMethodLogInfo::SignInAs(x) => { // struct let mut s = serializer.serialize_struct("AccessMethodLogInfo", 2)?; s.serialize_field(".tag", "sign_in_as")?; @@ -179,7 +179,7 @@ impl ::serde::ser::Serialize for AccountCaptureAvailability { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AccountCaptureAvailability::Available => { // unit let mut s = serializer.serialize_struct("AccountCaptureAvailability", 1)?; @@ -1030,7 +1030,7 @@ impl ::serde::ser::Serialize for AccountCaptureNotificationType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AccountCaptureNotificationType::ActionableNotification => { // unit let mut s = serializer.serialize_struct("AccountCaptureNotificationType", 1)?; @@ -1099,7 +1099,7 @@ impl ::serde::ser::Serialize for AccountCapturePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AccountCapturePolicy::AllUsers => { // unit let mut s = serializer.serialize_struct("AccountCapturePolicy", 1)?; @@ -1551,7 +1551,7 @@ impl ::serde::ser::Serialize for AccountState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AccountState::Locked => { // unit let mut s = serializer.serialize_struct("AccountState", 1)?; @@ -1627,22 +1627,22 @@ impl ::serde::ser::Serialize for ActionDetails { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ActionDetails::RemoveAction(ref x) => { + match self { + ActionDetails::RemoveAction(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ActionDetails", 2)?; s.serialize_field(".tag", "remove_action")?; s.serialize_field("remove_action", x)?; s.end() } - ActionDetails::TeamInviteDetails(ref x) => { + ActionDetails::TeamInviteDetails(x) => { // struct let mut s = serializer.serialize_struct("ActionDetails", 3)?; s.serialize_field(".tag", "team_invite_details")?; x.internal_serialize::(&mut s)?; s.end() } - ActionDetails::TeamJoinDetails(ref x) => { + ActionDetails::TeamJoinDetails(x) => { // struct let mut s = serializer.serialize_struct("ActionDetails", 10)?; s.serialize_field(".tag", "team_join_details")?; @@ -1736,8 +1736,8 @@ impl ::serde::ser::Serialize for ActorLogInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ActorLogInfo::Admin(ref x) => { + match self { + ActorLogInfo::Admin(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ActorLogInfo", 2)?; s.serialize_field(".tag", "admin")?; @@ -1750,7 +1750,7 @@ impl ::serde::ser::Serialize for ActorLogInfo { s.serialize_field(".tag", "anonymous")?; s.end() } - ActorLogInfo::App(ref x) => { + ActorLogInfo::App(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ActorLogInfo", 2)?; s.serialize_field(".tag", "app")?; @@ -1763,14 +1763,14 @@ impl ::serde::ser::Serialize for ActorLogInfo { s.serialize_field(".tag", "dropbox")?; s.end() } - ActorLogInfo::Reseller(ref x) => { + ActorLogInfo::Reseller(x) => { // struct let mut s = serializer.serialize_struct("ActorLogInfo", 3)?; s.serialize_field(".tag", "reseller")?; x.internal_serialize::(&mut s)?; s.end() } - ActorLogInfo::User(ref x) => { + ActorLogInfo::User(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ActorLogInfo", 2)?; s.serialize_field(".tag", "user")?; @@ -1843,7 +1843,7 @@ impl ::serde::ser::Serialize for AdminAlertCategoryEnum { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminAlertCategoryEnum::AccountTakeover => { // unit let mut s = serializer.serialize_struct("AdminAlertCategoryEnum", 1)?; @@ -1946,7 +1946,7 @@ impl ::serde::ser::Serialize for AdminAlertGeneralStateEnum { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminAlertGeneralStateEnum::Active => { // unit let mut s = serializer.serialize_struct("AdminAlertGeneralStateEnum", 1)?; @@ -2037,7 +2037,7 @@ impl ::serde::ser::Serialize for AdminAlertSeverityEnum { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminAlertSeverityEnum::High => { // unit let mut s = serializer.serialize_struct("AdminAlertSeverityEnum", 1)?; @@ -2289,7 +2289,7 @@ impl ::serde::ser::Serialize for AdminAlertingAlertSensitivity { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminAlertingAlertSensitivity::High => { // unit let mut s = serializer.serialize_struct("AdminAlertingAlertSensitivity", 1)?; @@ -2631,7 +2631,7 @@ impl ::serde::ser::Serialize for AdminAlertingAlertStatePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminAlertingAlertStatePolicy::Off => { // unit let mut s = serializer.serialize_struct("AdminAlertingAlertStatePolicy", 1)?; @@ -3132,7 +3132,7 @@ impl ::serde::ser::Serialize for AdminConsoleAppPermission { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminConsoleAppPermission::DefaultForListedApps => { // unit let mut s = serializer.serialize_struct("AdminConsoleAppPermission", 1)?; @@ -3198,7 +3198,7 @@ impl ::serde::ser::Serialize for AdminConsoleAppPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminConsoleAppPolicy::Allow => { // unit let mut s = serializer.serialize_struct("AdminConsoleAppPolicy", 1)?; @@ -3469,7 +3469,7 @@ impl ::serde::ser::Serialize for AdminEmailRemindersPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminEmailRemindersPolicy::Default => { // unit let mut s = serializer.serialize_struct("AdminEmailRemindersPolicy", 1)?; @@ -3562,7 +3562,7 @@ impl ::serde::ser::Serialize for AdminRole { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AdminRole::BillingAdmin => { // unit let mut s = serializer.serialize_struct("AdminRole", 1)?; @@ -3680,7 +3680,7 @@ impl ::serde::ser::Serialize for AlertRecipientsSettingType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AlertRecipientsSettingType::CustomList => { // unit let mut s = serializer.serialize_struct("AlertRecipientsSettingType", 1)?; @@ -4665,20 +4665,20 @@ impl ::serde::ser::Serialize for AppLogInfo { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - AppLogInfo::UserOrTeamLinkedApp(ref x) => { + match self { + AppLogInfo::UserOrTeamLinkedApp(x) => { let mut s = serializer.serialize_struct("AppLogInfo", 3)?; s.serialize_field(".tag", "user_or_team_linked_app")?; x.internal_serialize::(&mut s)?; s.end() } - AppLogInfo::UserLinkedApp(ref x) => { + AppLogInfo::UserLinkedApp(x) => { let mut s = serializer.serialize_struct("AppLogInfo", 3)?; s.serialize_field(".tag", "user_linked_app")?; x.internal_serialize::(&mut s)?; s.end() } - AppLogInfo::TeamLinkedApp(ref x) => { + AppLogInfo::TeamLinkedApp(x) => { let mut s = serializer.serialize_struct("AppLogInfo", 3)?; s.serialize_field(".tag", "team_linked_app")?; x.internal_serialize::(&mut s)?; @@ -5482,36 +5482,36 @@ impl ::serde::ser::Serialize for AssetLogInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - AssetLogInfo::File(ref x) => { + match self { + AssetLogInfo::File(x) => { // struct let mut s = serializer.serialize_struct("AssetLogInfo", 5)?; s.serialize_field(".tag", "file")?; x.internal_serialize::(&mut s)?; s.end() } - AssetLogInfo::Folder(ref x) => { + AssetLogInfo::Folder(x) => { // struct let mut s = serializer.serialize_struct("AssetLogInfo", 6)?; s.serialize_field(".tag", "folder")?; x.internal_serialize::(&mut s)?; s.end() } - AssetLogInfo::PaperDocument(ref x) => { + AssetLogInfo::PaperDocument(x) => { // struct let mut s = serializer.serialize_struct("AssetLogInfo", 3)?; s.serialize_field(".tag", "paper_document")?; x.internal_serialize::(&mut s)?; s.end() } - AssetLogInfo::PaperFolder(ref x) => { + AssetLogInfo::PaperFolder(x) => { // struct let mut s = serializer.serialize_struct("AssetLogInfo", 3)?; s.serialize_field(".tag", "paper_folder")?; x.internal_serialize::(&mut s)?; s.end() } - AssetLogInfo::ShowcaseDocument(ref x) => { + AssetLogInfo::ShowcaseDocument(x) => { // struct let mut s = serializer.serialize_struct("AssetLogInfo", 3)?; s.serialize_field(".tag", "showcase_document")?; @@ -5837,7 +5837,7 @@ impl ::serde::ser::Serialize for BackupStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { BackupStatus::Disabled => { // unit let mut s = serializer.serialize_struct("BackupStatus", 1)?; @@ -7605,7 +7605,7 @@ impl ::serde::ser::Serialize for CameraUploadsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { CameraUploadsPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("CameraUploadsPolicy", 1)?; @@ -7867,7 +7867,7 @@ impl ::serde::ser::Serialize for CaptureTranscriptPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { CaptureTranscriptPolicy::Default => { // unit let mut s = serializer.serialize_struct("CaptureTranscriptPolicy", 1)?; @@ -8320,7 +8320,7 @@ impl ::serde::ser::Serialize for ChangeLinkExpirationPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ChangeLinkExpirationPolicy::Allowed => { // unit let mut s = serializer.serialize_struct("ChangeLinkExpirationPolicy", 1)?; @@ -9352,7 +9352,7 @@ impl ::serde::ser::Serialize for ClassificationPolicyEnumWrapper { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ClassificationPolicyEnumWrapper::Disabled => { // unit let mut s = serializer.serialize_struct("ClassificationPolicyEnumWrapper", 1)?; @@ -9428,7 +9428,7 @@ impl ::serde::ser::Serialize for ClassificationType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ClassificationType::PersonalInformation => { // unit let mut s = serializer.serialize_struct("ClassificationType", 1)?; @@ -9677,7 +9677,7 @@ impl ::serde::ser::Serialize for ComputerBackupPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ComputerBackupPolicy::Default => { // unit let mut s = serializer.serialize_struct("ComputerBackupPolicy", 1)?; @@ -10229,7 +10229,7 @@ impl ::serde::ser::Serialize for ContentPermanentDeletePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ContentPermanentDeletePolicy::Disabled => { // unit let mut s = serializer.serialize_struct("ContentPermanentDeletePolicy", 1)?; @@ -10311,21 +10311,21 @@ impl ::serde::ser::Serialize for ContextLogInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ContextLogInfo::Anonymous => { // unit let mut s = serializer.serialize_struct("ContextLogInfo", 1)?; s.serialize_field(".tag", "anonymous")?; s.end() } - ContextLogInfo::NonTeamMember(ref x) => { + ContextLogInfo::NonTeamMember(x) => { // struct let mut s = serializer.serialize_struct("ContextLogInfo", 4)?; s.serialize_field(".tag", "non_team_member")?; x.internal_serialize::(&mut s)?; s.end() } - ContextLogInfo::OrganizationTeam(ref x) => { + ContextLogInfo::OrganizationTeam(x) => { // struct let mut s = serializer.serialize_struct("ContextLogInfo", 2)?; s.serialize_field(".tag", "organization_team")?; @@ -10338,14 +10338,14 @@ impl ::serde::ser::Serialize for ContextLogInfo { s.serialize_field(".tag", "team")?; s.end() } - ContextLogInfo::TeamMember(ref x) => { + ContextLogInfo::TeamMember(x) => { // struct let mut s = serializer.serialize_struct("ContextLogInfo", 7)?; s.serialize_field(".tag", "team_member")?; x.internal_serialize::(&mut s)?; s.end() } - ContextLogInfo::TrustedNonTeamMember(ref x) => { + ContextLogInfo::TrustedNonTeamMember(x) => { // struct let mut s = serializer.serialize_struct("ContextLogInfo", 6)?; s.serialize_field(".tag", "trusted_non_team_member")?; @@ -11395,7 +11395,7 @@ impl ::serde::ser::Serialize for DefaultLinkExpirationDaysPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DefaultLinkExpirationDaysPolicy::Day1 => { // unit let mut s = serializer.serialize_struct("DefaultLinkExpirationDaysPolicy", 1)?; @@ -12907,7 +12907,7 @@ impl ::serde::ser::Serialize for DeviceApprovalsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DeviceApprovalsPolicy::Limited => { // unit let mut s = serializer.serialize_struct("DeviceApprovalsPolicy", 1)?; @@ -14702,26 +14702,26 @@ impl ::serde::ser::Serialize for DeviceSessionLogInfo { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - DeviceSessionLogInfo::DesktopDeviceSession(ref x) => { + match self { + DeviceSessionLogInfo::DesktopDeviceSession(x) => { let mut s = serializer.serialize_struct("DeviceSessionLogInfo", 10)?; s.serialize_field(".tag", "desktop_device_session")?; x.internal_serialize::(&mut s)?; s.end() } - DeviceSessionLogInfo::MobileDeviceSession(ref x) => { + DeviceSessionLogInfo::MobileDeviceSession(x) => { let mut s = serializer.serialize_struct("DeviceSessionLogInfo", 10)?; s.serialize_field(".tag", "mobile_device_session")?; x.internal_serialize::(&mut s)?; s.end() } - DeviceSessionLogInfo::WebDeviceSession(ref x) => { + DeviceSessionLogInfo::WebDeviceSession(x) => { let mut s = serializer.serialize_struct("DeviceSessionLogInfo", 8)?; s.serialize_field(".tag", "web_device_session")?; x.internal_serialize::(&mut s)?; s.end() } - DeviceSessionLogInfo::LegacyDeviceSession(ref x) => { + DeviceSessionLogInfo::LegacyDeviceSession(x) => { let mut s = serializer.serialize_struct("DeviceSessionLogInfo", 13)?; s.serialize_field(".tag", "legacy_device_session")?; x.internal_serialize::(&mut s)?; @@ -14989,7 +14989,7 @@ impl ::serde::ser::Serialize for DeviceType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DeviceType::Desktop => { // unit let mut s = serializer.serialize_struct("DeviceType", 1)?; @@ -15184,7 +15184,7 @@ impl ::serde::ser::Serialize for DeviceUnlinkPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DeviceUnlinkPolicy::Keep => { // unit let mut s = serializer.serialize_struct("DeviceUnlinkPolicy", 1)?; @@ -15739,7 +15739,7 @@ impl ::serde::ser::Serialize for DispositionActionType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DispositionActionType::AutomaticDelete => { // unit let mut s = serializer.serialize_struct("DispositionActionType", 1)?; @@ -17254,7 +17254,7 @@ impl ::serde::ser::Serialize for DownloadPolicyType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DownloadPolicyType::Allow => { // unit let mut s = serializer.serialize_struct("DownloadPolicyType", 1)?; @@ -17698,7 +17698,7 @@ impl ::serde::ser::Serialize for DropboxPasswordsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { DropboxPasswordsPolicy::Default => { // unit let mut s = serializer.serialize_struct("DropboxPasswordsPolicy", 1)?; @@ -18068,7 +18068,7 @@ impl ::serde::ser::Serialize for EmailIngestPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { EmailIngestPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("EmailIngestPolicy", 1)?; @@ -20086,7 +20086,7 @@ impl ::serde::ser::Serialize for EnforceLinkPasswordPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { EnforceLinkPasswordPolicy::Optional => { // unit let mut s = serializer.serialize_struct("EnforceLinkPasswordPolicy", 1)?; @@ -20466,7 +20466,7 @@ impl ::serde::ser::Serialize for EventCategory { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { EventCategory::AdminAlerting => { // unit let mut s = serializer.serialize_struct("EventCategory", 1)?; @@ -22163,351 +22163,351 @@ impl ::serde::ser::Serialize for EventDetails { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - EventDetails::AdminAlertingAlertStateChangedDetails(ref x) => { + match self { + EventDetails::AdminAlertingAlertStateChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 7)?; s.serialize_field(".tag", "admin_alerting_alert_state_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AdminAlertingChangedAlertConfigDetails(ref x) => { + EventDetails::AdminAlertingChangedAlertConfigDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "admin_alerting_changed_alert_config_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AdminAlertingTriggeredAlertDetails(ref x) => { + EventDetails::AdminAlertingTriggeredAlertDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "admin_alerting_triggered_alert_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::RansomwareRestoreProcessCompletedDetails(ref x) => { + EventDetails::RansomwareRestoreProcessCompletedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "ransomware_restore_process_completed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::RansomwareRestoreProcessStartedDetails(ref x) => { + EventDetails::RansomwareRestoreProcessStartedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "ransomware_restore_process_started_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AppBlockedByPermissionsDetails(ref x) => { + EventDetails::AppBlockedByPermissionsDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "app_blocked_by_permissions_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AppLinkTeamDetails(ref x) => { + EventDetails::AppLinkTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "app_link_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AppLinkUserDetails(ref x) => { + EventDetails::AppLinkUserDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "app_link_user_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AppUnlinkTeamDetails(ref x) => { + EventDetails::AppUnlinkTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "app_unlink_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AppUnlinkUserDetails(ref x) => { + EventDetails::AppUnlinkUserDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "app_unlink_user_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::IntegrationConnectedDetails(ref x) => { + EventDetails::IntegrationConnectedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "integration_connected_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::IntegrationDisconnectedDetails(ref x) => { + EventDetails::IntegrationDisconnectedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "integration_disconnected_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileAddCommentDetails(ref x) => { + EventDetails::FileAddCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_add_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileChangeCommentSubscriptionDetails(ref x) => { + EventDetails::FileChangeCommentSubscriptionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_change_comment_subscription_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileDeleteCommentDetails(ref x) => { + EventDetails::FileDeleteCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_delete_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileEditCommentDetails(ref x) => { + EventDetails::FileEditCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_edit_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileLikeCommentDetails(ref x) => { + EventDetails::FileLikeCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_like_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileResolveCommentDetails(ref x) => { + EventDetails::FileResolveCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_resolve_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileUnlikeCommentDetails(ref x) => { + EventDetails::FileUnlikeCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_unlike_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileUnresolveCommentDetails(ref x) => { + EventDetails::FileUnresolveCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_unresolve_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyAddFoldersDetails(ref x) => { + EventDetails::GovernancePolicyAddFoldersDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "governance_policy_add_folders_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyAddFolderFailedDetails(ref x) => { + EventDetails::GovernancePolicyAddFolderFailedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "governance_policy_add_folder_failed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyContentDisposedDetails(ref x) => { + EventDetails::GovernancePolicyContentDisposedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "governance_policy_content_disposed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyCreateDetails(ref x) => { + EventDetails::GovernancePolicyCreateDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "governance_policy_create_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyDeleteDetails(ref x) => { + EventDetails::GovernancePolicyDeleteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "governance_policy_delete_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyEditDetailsDetails(ref x) => { + EventDetails::GovernancePolicyEditDetailsDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 7)?; s.serialize_field(".tag", "governance_policy_edit_details_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyEditDurationDetails(ref x) => { + EventDetails::GovernancePolicyEditDurationDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "governance_policy_edit_duration_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyExportCreatedDetails(ref x) => { + EventDetails::GovernancePolicyExportCreatedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "governance_policy_export_created_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyExportRemovedDetails(ref x) => { + EventDetails::GovernancePolicyExportRemovedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "governance_policy_export_removed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyRemoveFoldersDetails(ref x) => { + EventDetails::GovernancePolicyRemoveFoldersDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "governance_policy_remove_folders_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyReportCreatedDetails(ref x) => { + EventDetails::GovernancePolicyReportCreatedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "governance_policy_report_created_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GovernancePolicyZipPartDownloadedDetails(ref x) => { + EventDetails::GovernancePolicyZipPartDownloadedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "governance_policy_zip_part_downloaded_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsActivateAHoldDetails(ref x) => { + EventDetails::LegalHoldsActivateAHoldDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "legal_holds_activate_a_hold_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsAddMembersDetails(ref x) => { + EventDetails::LegalHoldsAddMembersDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "legal_holds_add_members_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsChangeHoldDetailsDetails(ref x) => { + EventDetails::LegalHoldsChangeHoldDetailsDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "legal_holds_change_hold_details_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsChangeHoldNameDetails(ref x) => { + EventDetails::LegalHoldsChangeHoldNameDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "legal_holds_change_hold_name_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsExportAHoldDetails(ref x) => { + EventDetails::LegalHoldsExportAHoldDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "legal_holds_export_a_hold_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsExportCancelledDetails(ref x) => { + EventDetails::LegalHoldsExportCancelledDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "legal_holds_export_cancelled_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsExportDownloadedDetails(ref x) => { + EventDetails::LegalHoldsExportDownloadedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "legal_holds_export_downloaded_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsExportRemovedDetails(ref x) => { + EventDetails::LegalHoldsExportRemovedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "legal_holds_export_removed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsReleaseAHoldDetails(ref x) => { + EventDetails::LegalHoldsReleaseAHoldDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "legal_holds_release_a_hold_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsRemoveMembersDetails(ref x) => { + EventDetails::LegalHoldsRemoveMembersDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "legal_holds_remove_members_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LegalHoldsReportAHoldDetails(ref x) => { + EventDetails::LegalHoldsReportAHoldDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "legal_holds_report_a_hold_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceChangeIpDesktopDetails(ref x) => { + EventDetails::DeviceChangeIpDesktopDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "device_change_ip_desktop_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceChangeIpMobileDetails(ref x) => { + EventDetails::DeviceChangeIpMobileDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "device_change_ip_mobile_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceChangeIpWebDetails(ref x) => { + EventDetails::DeviceChangeIpWebDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "device_change_ip_web_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceDeleteOnUnlinkFailDetails(ref x) => { + EventDetails::DeviceDeleteOnUnlinkFailDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "device_delete_on_unlink_fail_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceDeleteOnUnlinkSuccessDetails(ref x) => { + EventDetails::DeviceDeleteOnUnlinkSuccessDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "device_delete_on_unlink_success_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceLinkFailDetails(ref x) => { + EventDetails::DeviceLinkFailDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "device_link_fail_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceLinkSuccessDetails(ref x) => { + EventDetails::DeviceLinkSuccessDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "device_link_success_details")?; @@ -22526,28 +22526,28 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "device_management_enabled_details")?; s.end() } - EventDetails::DeviceSyncBackupStatusChangedDetails(ref x) => { + EventDetails::DeviceSyncBackupStatusChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "device_sync_backup_status_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceUnlinkDetails(ref x) => { + EventDetails::DeviceUnlinkDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "device_unlink_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DropboxPasswordsExportedDetails(ref x) => { + EventDetails::DropboxPasswordsExportedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "dropbox_passwords_exported_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DropboxPasswordsNewDeviceEnrolledDetails(ref x) => { + EventDetails::DropboxPasswordsNewDeviceEnrolledDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "dropbox_passwords_new_device_enrolled_details")?; @@ -22560,42 +22560,42 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "emm_refresh_auth_token_details")?; s.end() } - EventDetails::ExternalDriveBackupEligibilityStatusCheckedDetails(ref x) => { + EventDetails::ExternalDriveBackupEligibilityStatusCheckedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "external_drive_backup_eligibility_status_checked_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ExternalDriveBackupStatusChangedDetails(ref x) => { + EventDetails::ExternalDriveBackupStatusChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "external_drive_backup_status_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AccountCaptureChangeAvailabilityDetails(ref x) => { + EventDetails::AccountCaptureChangeAvailabilityDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "account_capture_change_availability_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AccountCaptureMigrateAccountDetails(ref x) => { + EventDetails::AccountCaptureMigrateAccountDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "account_capture_migrate_account_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AccountCaptureNotificationEmailsSentDetails(ref x) => { + EventDetails::AccountCaptureNotificationEmailsSentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "account_capture_notification_emails_sent_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AccountCaptureRelinquishAccountDetails(ref x) => { + EventDetails::AccountCaptureRelinquishAccountDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "account_capture_relinquish_account_details")?; @@ -22620,7 +22620,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "domain_invites_decline_request_to_join_team_details")?; s.end() } - EventDetails::DomainInvitesEmailExistingUsersDetails(ref x) => { + EventDetails::DomainInvitesEmailExistingUsersDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "domain_invites_email_existing_users_details")?; @@ -22645,21 +22645,21 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "domain_invites_set_invite_new_user_pref_to_yes_details")?; s.end() } - EventDetails::DomainVerificationAddDomainFailDetails(ref x) => { + EventDetails::DomainVerificationAddDomainFailDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "domain_verification_add_domain_fail_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DomainVerificationAddDomainSuccessDetails(ref x) => { + EventDetails::DomainVerificationAddDomainSuccessDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "domain_verification_add_domain_success_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DomainVerificationRemoveDomainDetails(ref x) => { + EventDetails::DomainVerificationRemoveDomainDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "domain_verification_remove_domain_details")?; @@ -22738,7 +22738,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "file_add_from_automation_details")?; s.end() } - EventDetails::FileCopyDetails(ref x) => { + EventDetails::FileCopyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_copy_details")?; @@ -22769,14 +22769,14 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "file_get_copy_reference_details")?; s.end() } - EventDetails::FileLockingLockStatusChangedDetails(ref x) => { + EventDetails::FileLockingLockStatusChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_locking_lock_status_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileMoveDetails(ref x) => { + EventDetails::FileMoveDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_move_details")?; @@ -22795,7 +22795,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "file_preview_details")?; s.end() } - EventDetails::FileRenameDetails(ref x) => { + EventDetails::FileRenameDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_rename_details")?; @@ -22820,49 +22820,49 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "file_rollback_changes_details")?; s.end() } - EventDetails::FileSaveCopyReferenceDetails(ref x) => { + EventDetails::FileSaveCopyReferenceDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_save_copy_reference_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FolderOverviewDescriptionChangedDetails(ref x) => { + EventDetails::FolderOverviewDescriptionChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "folder_overview_description_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FolderOverviewItemPinnedDetails(ref x) => { + EventDetails::FolderOverviewItemPinnedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "folder_overview_item_pinned_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FolderOverviewItemUnpinnedDetails(ref x) => { + EventDetails::FolderOverviewItemUnpinnedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "folder_overview_item_unpinned_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ObjectLabelAddedDetails(ref x) => { + EventDetails::ObjectLabelAddedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "object_label_added_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ObjectLabelRemovedDetails(ref x) => { + EventDetails::ObjectLabelRemovedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "object_label_removed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ObjectLabelUpdatedValueDetails(ref x) => { + EventDetails::ObjectLabelUpdatedValueDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "object_label_updated_value_details")?; @@ -22881,7 +22881,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "replay_file_delete_details")?; s.end() } - EventDetails::RewindFolderDetails(ref x) => { + EventDetails::RewindFolderDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "rewind_folder_details")?; @@ -22900,105 +22900,105 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "undo_organize_folder_with_tidy_details")?; s.end() } - EventDetails::UserTagsAddedDetails(ref x) => { + EventDetails::UserTagsAddedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "user_tags_added_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::UserTagsRemovedDetails(ref x) => { + EventDetails::UserTagsRemovedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "user_tags_removed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::EmailIngestReceiveFileDetails(ref x) => { + EventDetails::EmailIngestReceiveFileDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "email_ingest_receive_file_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileRequestChangeDetails(ref x) => { + EventDetails::FileRequestChangeDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "file_request_change_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileRequestCloseDetails(ref x) => { + EventDetails::FileRequestCloseDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_request_close_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileRequestCreateDetails(ref x) => { + EventDetails::FileRequestCreateDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_request_create_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileRequestDeleteDetails(ref x) => { + EventDetails::FileRequestDeleteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_request_delete_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileRequestReceiveFileDetails(ref x) => { + EventDetails::FileRequestReceiveFileDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "file_request_receive_file_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GroupAddExternalIdDetails(ref x) => { + EventDetails::GroupAddExternalIdDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "group_add_external_id_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GroupAddMemberDetails(ref x) => { + EventDetails::GroupAddMemberDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "group_add_member_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GroupChangeExternalIdDetails(ref x) => { + EventDetails::GroupChangeExternalIdDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "group_change_external_id_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GroupChangeManagementTypeDetails(ref x) => { + EventDetails::GroupChangeManagementTypeDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "group_change_management_type_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GroupChangeMemberRoleDetails(ref x) => { + EventDetails::GroupChangeMemberRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "group_change_member_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GroupCreateDetails(ref x) => { + EventDetails::GroupCreateDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "group_create_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GroupDeleteDetails(ref x) => { + EventDetails::GroupDeleteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "group_delete_details")?; @@ -23011,7 +23011,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "group_description_updated_details")?; s.end() } - EventDetails::GroupJoinPolicyUpdatedDetails(ref x) => { + EventDetails::GroupJoinPolicyUpdatedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "group_join_policy_updated_details")?; @@ -23024,7 +23024,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "group_moved_details")?; s.end() } - EventDetails::GroupRemoveExternalIdDetails(ref x) => { + EventDetails::GroupRemoveExternalIdDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "group_remove_external_id_details")?; @@ -23037,56 +23037,56 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "group_remove_member_details")?; s.end() } - EventDetails::GroupRenameDetails(ref x) => { + EventDetails::GroupRenameDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "group_rename_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AccountLockOrUnlockedDetails(ref x) => { + EventDetails::AccountLockOrUnlockedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "account_lock_or_unlocked_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::EmmErrorDetails(ref x) => { + EventDetails::EmmErrorDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "emm_error_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GuestAdminSignedInViaTrustedTeamsDetails(ref x) => { + EventDetails::GuestAdminSignedInViaTrustedTeamsDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "guest_admin_signed_in_via_trusted_teams_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GuestAdminSignedOutViaTrustedTeamsDetails(ref x) => { + EventDetails::GuestAdminSignedOutViaTrustedTeamsDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "guest_admin_signed_out_via_trusted_teams_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LoginFailDetails(ref x) => { + EventDetails::LoginFailDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "login_fail_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LoginSuccessDetails(ref x) => { + EventDetails::LoginSuccessDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "login_success_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::LogoutDetails(ref x) => { + EventDetails::LogoutDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "logout_details")?; @@ -23117,7 +23117,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "sign_in_as_session_start_details")?; s.end() } - EventDetails::SsoErrorDetails(ref x) => { + EventDetails::SsoErrorDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "sso_error_details")?; @@ -23136,77 +23136,77 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "backup_invitation_opened_details")?; s.end() } - EventDetails::CreateTeamInviteLinkDetails(ref x) => { + EventDetails::CreateTeamInviteLinkDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "create_team_invite_link_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeleteTeamInviteLinkDetails(ref x) => { + EventDetails::DeleteTeamInviteLinkDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "delete_team_invite_link_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberAddExternalIdDetails(ref x) => { + EventDetails::MemberAddExternalIdDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "member_add_external_id_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberAddNameDetails(ref x) => { + EventDetails::MemberAddNameDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "member_add_name_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberChangeAdminRoleDetails(ref x) => { + EventDetails::MemberChangeAdminRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_change_admin_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberChangeEmailDetails(ref x) => { + EventDetails::MemberChangeEmailDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_change_email_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberChangeExternalIdDetails(ref x) => { + EventDetails::MemberChangeExternalIdDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_change_external_id_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberChangeMembershipTypeDetails(ref x) => { + EventDetails::MemberChangeMembershipTypeDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_change_membership_type_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberChangeNameDetails(ref x) => { + EventDetails::MemberChangeNameDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_change_name_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberChangeResellerRoleDetails(ref x) => { + EventDetails::MemberChangeResellerRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_change_reseller_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberChangeStatusDetails(ref x) => { + EventDetails::MemberChangeStatusDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 6)?; s.serialize_field(".tag", "member_change_status_details")?; @@ -23231,7 +23231,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "member_permanently_delete_account_contents_details")?; s.end() } - EventDetails::MemberRemoveExternalIdDetails(ref x) => { + EventDetails::MemberRemoveExternalIdDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "member_remove_external_id_details")?; @@ -23244,21 +23244,21 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "member_set_profile_photo_details")?; s.end() } - EventDetails::MemberSpaceLimitsAddCustomQuotaDetails(ref x) => { + EventDetails::MemberSpaceLimitsAddCustomQuotaDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "member_space_limits_add_custom_quota_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberSpaceLimitsChangeCustomQuotaDetails(ref x) => { + EventDetails::MemberSpaceLimitsChangeCustomQuotaDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_space_limits_change_custom_quota_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberSpaceLimitsChangeStatusDetails(ref x) => { + EventDetails::MemberSpaceLimitsChangeStatusDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_space_limits_change_status_details")?; @@ -23271,7 +23271,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "member_space_limits_remove_custom_quota_details")?; s.end() } - EventDetails::MemberSuggestDetails(ref x) => { + EventDetails::MemberSuggestDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "member_suggest_details")?; @@ -23284,371 +23284,371 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "member_transfer_account_contents_details")?; s.end() } - EventDetails::PendingSecondaryEmailAddedDetails(ref x) => { + EventDetails::PendingSecondaryEmailAddedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "pending_secondary_email_added_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SecondaryEmailDeletedDetails(ref x) => { + EventDetails::SecondaryEmailDeletedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "secondary_email_deleted_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SecondaryEmailVerifiedDetails(ref x) => { + EventDetails::SecondaryEmailVerifiedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "secondary_email_verified_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SecondaryMailsPolicyChangedDetails(ref x) => { + EventDetails::SecondaryMailsPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "secondary_mails_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::BinderAddPageDetails(ref x) => { + EventDetails::BinderAddPageDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "binder_add_page_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::BinderAddSectionDetails(ref x) => { + EventDetails::BinderAddSectionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "binder_add_section_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::BinderRemovePageDetails(ref x) => { + EventDetails::BinderRemovePageDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "binder_remove_page_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::BinderRemoveSectionDetails(ref x) => { + EventDetails::BinderRemoveSectionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "binder_remove_section_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::BinderRenamePageDetails(ref x) => { + EventDetails::BinderRenamePageDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "binder_rename_page_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::BinderRenameSectionDetails(ref x) => { + EventDetails::BinderRenameSectionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "binder_rename_section_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::BinderReorderPageDetails(ref x) => { + EventDetails::BinderReorderPageDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "binder_reorder_page_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::BinderReorderSectionDetails(ref x) => { + EventDetails::BinderReorderSectionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "binder_reorder_section_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentAddMemberDetails(ref x) => { + EventDetails::PaperContentAddMemberDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_content_add_member_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentAddToFolderDetails(ref x) => { + EventDetails::PaperContentAddToFolderDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "paper_content_add_to_folder_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentArchiveDetails(ref x) => { + EventDetails::PaperContentArchiveDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_content_archive_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentCreateDetails(ref x) => { + EventDetails::PaperContentCreateDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_content_create_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentPermanentlyDeleteDetails(ref x) => { + EventDetails::PaperContentPermanentlyDeleteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_content_permanently_delete_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentRemoveFromFolderDetails(ref x) => { + EventDetails::PaperContentRemoveFromFolderDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "paper_content_remove_from_folder_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentRemoveMemberDetails(ref x) => { + EventDetails::PaperContentRemoveMemberDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_content_remove_member_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentRenameDetails(ref x) => { + EventDetails::PaperContentRenameDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_content_rename_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperContentRestoreDetails(ref x) => { + EventDetails::PaperContentRestoreDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_content_restore_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocAddCommentDetails(ref x) => { + EventDetails::PaperDocAddCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_doc_add_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocChangeMemberRoleDetails(ref x) => { + EventDetails::PaperDocChangeMemberRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_doc_change_member_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocChangeSharingPolicyDetails(ref x) => { + EventDetails::PaperDocChangeSharingPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "paper_doc_change_sharing_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocChangeSubscriptionDetails(ref x) => { + EventDetails::PaperDocChangeSubscriptionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "paper_doc_change_subscription_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocDeletedDetails(ref x) => { + EventDetails::PaperDocDeletedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_deleted_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocDeleteCommentDetails(ref x) => { + EventDetails::PaperDocDeleteCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_doc_delete_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocDownloadDetails(ref x) => { + EventDetails::PaperDocDownloadDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_doc_download_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocEditDetails(ref x) => { + EventDetails::PaperDocEditDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_edit_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocEditCommentDetails(ref x) => { + EventDetails::PaperDocEditCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_doc_edit_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocFollowedDetails(ref x) => { + EventDetails::PaperDocFollowedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_followed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocMentionDetails(ref x) => { + EventDetails::PaperDocMentionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_mention_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocOwnershipChangedDetails(ref x) => { + EventDetails::PaperDocOwnershipChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "paper_doc_ownership_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocRequestAccessDetails(ref x) => { + EventDetails::PaperDocRequestAccessDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_request_access_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocResolveCommentDetails(ref x) => { + EventDetails::PaperDocResolveCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_doc_resolve_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocRevertDetails(ref x) => { + EventDetails::PaperDocRevertDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_revert_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocSlackShareDetails(ref x) => { + EventDetails::PaperDocSlackShareDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_slack_share_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocTeamInviteDetails(ref x) => { + EventDetails::PaperDocTeamInviteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_team_invite_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocTrashedDetails(ref x) => { + EventDetails::PaperDocTrashedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_trashed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocUnresolveCommentDetails(ref x) => { + EventDetails::PaperDocUnresolveCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_doc_unresolve_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocUntrashedDetails(ref x) => { + EventDetails::PaperDocUntrashedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_untrashed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDocViewDetails(ref x) => { + EventDetails::PaperDocViewDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_doc_view_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperExternalViewAllowDetails(ref x) => { + EventDetails::PaperExternalViewAllowDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_external_view_allow_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperExternalViewDefaultTeamDetails(ref x) => { + EventDetails::PaperExternalViewDefaultTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_external_view_default_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperExternalViewForbidDetails(ref x) => { + EventDetails::PaperExternalViewForbidDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_external_view_forbid_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperFolderChangeSubscriptionDetails(ref x) => { + EventDetails::PaperFolderChangeSubscriptionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "paper_folder_change_subscription_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperFolderDeletedDetails(ref x) => { + EventDetails::PaperFolderDeletedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_folder_deleted_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperFolderFollowedDetails(ref x) => { + EventDetails::PaperFolderFollowedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_folder_followed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperFolderTeamInviteDetails(ref x) => { + EventDetails::PaperFolderTeamInviteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_folder_team_invite_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperPublishedLinkChangePermissionDetails(ref x) => { + EventDetails::PaperPublishedLinkChangePermissionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "paper_published_link_change_permission_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperPublishedLinkCreateDetails(ref x) => { + EventDetails::PaperPublishedLinkCreateDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_published_link_create_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperPublishedLinkDisabledDetails(ref x) => { + EventDetails::PaperPublishedLinkDisabledDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_published_link_disabled_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperPublishedLinkViewDetails(ref x) => { + EventDetails::PaperPublishedLinkViewDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_published_link_view_details")?; @@ -23679,7 +23679,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "classification_create_report_details")?; s.end() } - EventDetails::ClassificationCreateReportFailDetails(ref x) => { + EventDetails::ClassificationCreateReportFailDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "classification_create_report_fail_details")?; @@ -23704,7 +23704,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "export_members_report_details")?; s.end() } - EventDetails::ExportMembersReportFailDetails(ref x) => { + EventDetails::ExportMembersReportFailDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "export_members_report_fail_details")?; @@ -23717,63 +23717,63 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "external_sharing_create_report_details")?; s.end() } - EventDetails::ExternalSharingReportFailedDetails(ref x) => { + EventDetails::ExternalSharingReportFailedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "external_sharing_report_failed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::NoExpirationLinkGenCreateReportDetails(ref x) => { + EventDetails::NoExpirationLinkGenCreateReportDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "no_expiration_link_gen_create_report_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::NoExpirationLinkGenReportFailedDetails(ref x) => { + EventDetails::NoExpirationLinkGenReportFailedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "no_expiration_link_gen_report_failed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::NoPasswordLinkGenCreateReportDetails(ref x) => { + EventDetails::NoPasswordLinkGenCreateReportDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "no_password_link_gen_create_report_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::NoPasswordLinkGenReportFailedDetails(ref x) => { + EventDetails::NoPasswordLinkGenReportFailedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "no_password_link_gen_report_failed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::NoPasswordLinkViewCreateReportDetails(ref x) => { + EventDetails::NoPasswordLinkViewCreateReportDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "no_password_link_view_create_report_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::NoPasswordLinkViewReportFailedDetails(ref x) => { + EventDetails::NoPasswordLinkViewReportFailedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "no_password_link_view_report_failed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::OutdatedLinkViewCreateReportDetails(ref x) => { + EventDetails::OutdatedLinkViewCreateReportDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "outdated_link_view_create_report_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::OutdatedLinkViewReportFailedDetails(ref x) => { + EventDetails::OutdatedLinkViewReportFailedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "outdated_link_view_report_failed_details")?; @@ -23792,7 +23792,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "ransomware_alert_create_report_details")?; s.end() } - EventDetails::RansomwareAlertCreateReportFailedDetails(ref x) => { + EventDetails::RansomwareAlertCreateReportFailedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "ransomware_alert_create_report_failed_details")?; @@ -23805,56 +23805,56 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "smart_sync_create_admin_privilege_report_details")?; s.end() } - EventDetails::TeamActivityCreateReportDetails(ref x) => { + EventDetails::TeamActivityCreateReportDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_activity_create_report_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamActivityCreateReportFailDetails(ref x) => { + EventDetails::TeamActivityCreateReportFailDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_activity_create_report_fail_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::CollectionShareDetails(ref x) => { + EventDetails::CollectionShareDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "collection_share_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileTransfersFileAddDetails(ref x) => { + EventDetails::FileTransfersFileAddDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_transfers_file_add_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileTransfersTransferDeleteDetails(ref x) => { + EventDetails::FileTransfersTransferDeleteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_transfers_transfer_delete_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileTransfersTransferDownloadDetails(ref x) => { + EventDetails::FileTransfersTransferDownloadDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_transfers_transfer_download_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileTransfersTransferSendDetails(ref x) => { + EventDetails::FileTransfersTransferSendDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_transfers_transfer_send_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileTransfersTransferViewDetails(ref x) => { + EventDetails::FileTransfersTransferViewDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "file_transfers_transfer_view_details")?; @@ -23921,105 +23921,105 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "replay_project_team_delete_details")?; s.end() } - EventDetails::SfAddGroupDetails(ref x) => { + EventDetails::SfAddGroupDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "sf_add_group_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfAllowNonMembersToViewSharedLinksDetails(ref x) => { + EventDetails::SfAllowNonMembersToViewSharedLinksDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "sf_allow_non_members_to_view_shared_links_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfExternalInviteWarnDetails(ref x) => { + EventDetails::SfExternalInviteWarnDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "sf_external_invite_warn_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfFbInviteDetails(ref x) => { + EventDetails::SfFbInviteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "sf_fb_invite_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfFbInviteChangeRoleDetails(ref x) => { + EventDetails::SfFbInviteChangeRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "sf_fb_invite_change_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfFbUninviteDetails(ref x) => { + EventDetails::SfFbUninviteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sf_fb_uninvite_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfInviteGroupDetails(ref x) => { + EventDetails::SfInviteGroupDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "sf_invite_group_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfTeamGrantAccessDetails(ref x) => { + EventDetails::SfTeamGrantAccessDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sf_team_grant_access_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfTeamInviteDetails(ref x) => { + EventDetails::SfTeamInviteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "sf_team_invite_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfTeamInviteChangeRoleDetails(ref x) => { + EventDetails::SfTeamInviteChangeRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "sf_team_invite_change_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfTeamJoinDetails(ref x) => { + EventDetails::SfTeamJoinDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sf_team_join_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfTeamJoinFromOobLinkDetails(ref x) => { + EventDetails::SfTeamJoinFromOobLinkDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "sf_team_join_from_oob_link_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SfTeamUninviteDetails(ref x) => { + EventDetails::SfTeamUninviteDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sf_team_uninvite_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentAddInviteesDetails(ref x) => { + EventDetails::SharedContentAddInviteesDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_content_add_invitees_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentAddLinkExpiryDetails(ref x) => { + EventDetails::SharedContentAddLinkExpiryDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_content_add_link_expiry_details")?; @@ -24032,35 +24032,35 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shared_content_add_link_password_details")?; s.end() } - EventDetails::SharedContentAddMemberDetails(ref x) => { + EventDetails::SharedContentAddMemberDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_content_add_member_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentChangeDownloadsPolicyDetails(ref x) => { + EventDetails::SharedContentChangeDownloadsPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_content_change_downloads_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentChangeInviteeRoleDetails(ref x) => { + EventDetails::SharedContentChangeInviteeRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "shared_content_change_invitee_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentChangeLinkAudienceDetails(ref x) => { + EventDetails::SharedContentChangeLinkAudienceDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_content_change_link_audience_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentChangeLinkExpiryDetails(ref x) => { + EventDetails::SharedContentChangeLinkExpiryDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_content_change_link_expiry_details")?; @@ -24073,35 +24073,35 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shared_content_change_link_password_details")?; s.end() } - EventDetails::SharedContentChangeMemberRoleDetails(ref x) => { + EventDetails::SharedContentChangeMemberRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_content_change_member_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentChangeViewerInfoPolicyDetails(ref x) => { + EventDetails::SharedContentChangeViewerInfoPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_content_change_viewer_info_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentClaimInvitationDetails(ref x) => { + EventDetails::SharedContentClaimInvitationDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_content_claim_invitation_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentCopyDetails(ref x) => { + EventDetails::SharedContentCopyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "shared_content_copy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentDownloadDetails(ref x) => { + EventDetails::SharedContentDownloadDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "shared_content_download_details")?; @@ -24114,14 +24114,14 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shared_content_relinquish_membership_details")?; s.end() } - EventDetails::SharedContentRemoveInviteesDetails(ref x) => { + EventDetails::SharedContentRemoveInviteesDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_content_remove_invitees_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentRemoveLinkExpiryDetails(ref x) => { + EventDetails::SharedContentRemoveLinkExpiryDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_content_remove_link_expiry_details")?; @@ -24134,28 +24134,28 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shared_content_remove_link_password_details")?; s.end() } - EventDetails::SharedContentRemoveMemberDetails(ref x) => { + EventDetails::SharedContentRemoveMemberDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_content_remove_member_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentRequestAccessDetails(ref x) => { + EventDetails::SharedContentRequestAccessDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_content_request_access_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentRestoreInviteesDetails(ref x) => { + EventDetails::SharedContentRestoreInviteesDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_content_restore_invitees_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedContentRestoreMemberDetails(ref x) => { + EventDetails::SharedContentRestoreMemberDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_content_restore_member_details")?; @@ -24168,42 +24168,42 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shared_content_unshare_details")?; s.end() } - EventDetails::SharedContentViewDetails(ref x) => { + EventDetails::SharedContentViewDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "shared_content_view_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedFolderChangeLinkPolicyDetails(ref x) => { + EventDetails::SharedFolderChangeLinkPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_folder_change_link_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedFolderChangeMembersInheritancePolicyDetails(ref x) => { + EventDetails::SharedFolderChangeMembersInheritancePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_folder_change_members_inheritance_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedFolderChangeMembersManagementPolicyDetails(ref x) => { + EventDetails::SharedFolderChangeMembersManagementPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_folder_change_members_management_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedFolderChangeMembersPolicyDetails(ref x) => { + EventDetails::SharedFolderChangeMembersPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_folder_change_members_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedFolderCreateDetails(ref x) => { + EventDetails::SharedFolderCreateDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_folder_create_details")?; @@ -24222,14 +24222,14 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shared_folder_mount_details")?; s.end() } - EventDetails::SharedFolderNestDetails(ref x) => { + EventDetails::SharedFolderNestDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "shared_folder_nest_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedFolderTransferOwnershipDetails(ref x) => { + EventDetails::SharedFolderTransferOwnershipDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_folder_transfer_ownership_details")?; @@ -24242,133 +24242,133 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shared_folder_unmount_details")?; s.end() } - EventDetails::SharedLinkAddExpiryDetails(ref x) => { + EventDetails::SharedLinkAddExpiryDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_link_add_expiry_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkChangeExpiryDetails(ref x) => { + EventDetails::SharedLinkChangeExpiryDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_link_change_expiry_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkChangeVisibilityDetails(ref x) => { + EventDetails::SharedLinkChangeVisibilityDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_link_change_visibility_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkCopyDetails(ref x) => { + EventDetails::SharedLinkCopyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_link_copy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkCreateDetails(ref x) => { + EventDetails::SharedLinkCreateDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_link_create_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkDisableDetails(ref x) => { + EventDetails::SharedLinkDisableDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_link_disable_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkDownloadDetails(ref x) => { + EventDetails::SharedLinkDownloadDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_link_download_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkRemoveExpiryDetails(ref x) => { + EventDetails::SharedLinkRemoveExpiryDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_link_remove_expiry_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsAddExpirationDetails(ref x) => { + EventDetails::SharedLinkSettingsAddExpirationDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "shared_link_settings_add_expiration_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsAddPasswordDetails(ref x) => { + EventDetails::SharedLinkSettingsAddPasswordDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_link_settings_add_password_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsAllowDownloadDisabledDetails(ref x) => { + EventDetails::SharedLinkSettingsAllowDownloadDisabledDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_link_settings_allow_download_disabled_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsAllowDownloadEnabledDetails(ref x) => { + EventDetails::SharedLinkSettingsAllowDownloadEnabledDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_link_settings_allow_download_enabled_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsChangeAudienceDetails(ref x) => { + EventDetails::SharedLinkSettingsChangeAudienceDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "shared_link_settings_change_audience_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsChangeExpirationDetails(ref x) => { + EventDetails::SharedLinkSettingsChangeExpirationDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "shared_link_settings_change_expiration_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsChangePasswordDetails(ref x) => { + EventDetails::SharedLinkSettingsChangePasswordDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_link_settings_change_password_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsRemoveExpirationDetails(ref x) => { + EventDetails::SharedLinkSettingsRemoveExpirationDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "shared_link_settings_remove_expiration_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkSettingsRemovePasswordDetails(ref x) => { + EventDetails::SharedLinkSettingsRemovePasswordDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_link_settings_remove_password_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkShareDetails(ref x) => { + EventDetails::SharedLinkShareDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "shared_link_share_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharedLinkViewDetails(ref x) => { + EventDetails::SharedLinkViewDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shared_link_view_details")?; @@ -24381,14 +24381,14 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shared_note_opened_details")?; s.end() } - EventDetails::ShmodelDisableDownloadsDetails(ref x) => { + EventDetails::ShmodelDisableDownloadsDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shmodel_disable_downloads_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShmodelEnableDownloadsDetails(ref x) => { + EventDetails::ShmodelEnableDownloadsDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "shmodel_enable_downloads_details")?; @@ -24401,217 +24401,217 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "shmodel_group_share_details")?; s.end() } - EventDetails::ShowcaseAccessGrantedDetails(ref x) => { + EventDetails::ShowcaseAccessGrantedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_access_granted_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseAddMemberDetails(ref x) => { + EventDetails::ShowcaseAddMemberDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_add_member_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseArchivedDetails(ref x) => { + EventDetails::ShowcaseArchivedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_archived_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseCreatedDetails(ref x) => { + EventDetails::ShowcaseCreatedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_created_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseDeleteCommentDetails(ref x) => { + EventDetails::ShowcaseDeleteCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_delete_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseEditedDetails(ref x) => { + EventDetails::ShowcaseEditedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_edited_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseEditCommentDetails(ref x) => { + EventDetails::ShowcaseEditCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_edit_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseFileAddedDetails(ref x) => { + EventDetails::ShowcaseFileAddedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_file_added_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseFileDownloadDetails(ref x) => { + EventDetails::ShowcaseFileDownloadDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_file_download_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseFileRemovedDetails(ref x) => { + EventDetails::ShowcaseFileRemovedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_file_removed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseFileViewDetails(ref x) => { + EventDetails::ShowcaseFileViewDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_file_view_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcasePermanentlyDeletedDetails(ref x) => { + EventDetails::ShowcasePermanentlyDeletedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_permanently_deleted_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcasePostCommentDetails(ref x) => { + EventDetails::ShowcasePostCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_post_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseRemoveMemberDetails(ref x) => { + EventDetails::ShowcaseRemoveMemberDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_remove_member_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseRenamedDetails(ref x) => { + EventDetails::ShowcaseRenamedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_renamed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseRequestAccessDetails(ref x) => { + EventDetails::ShowcaseRequestAccessDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_request_access_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseResolveCommentDetails(ref x) => { + EventDetails::ShowcaseResolveCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_resolve_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseRestoredDetails(ref x) => { + EventDetails::ShowcaseRestoredDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_restored_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseTrashedDetails(ref x) => { + EventDetails::ShowcaseTrashedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_trashed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseTrashedDeprecatedDetails(ref x) => { + EventDetails::ShowcaseTrashedDeprecatedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_trashed_deprecated_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseUnresolveCommentDetails(ref x) => { + EventDetails::ShowcaseUnresolveCommentDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_unresolve_comment_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseUntrashedDetails(ref x) => { + EventDetails::ShowcaseUntrashedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_untrashed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseUntrashedDeprecatedDetails(ref x) => { + EventDetails::ShowcaseUntrashedDeprecatedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_untrashed_deprecated_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseViewDetails(ref x) => { + EventDetails::ShowcaseViewDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "showcase_view_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoAddCertDetails(ref x) => { + EventDetails::SsoAddCertDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "sso_add_cert_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoAddLoginUrlDetails(ref x) => { + EventDetails::SsoAddLoginUrlDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "sso_add_login_url_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoAddLogoutUrlDetails(ref x) => { + EventDetails::SsoAddLogoutUrlDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "sso_add_logout_url_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoChangeCertDetails(ref x) => { + EventDetails::SsoChangeCertDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sso_change_cert_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoChangeLoginUrlDetails(ref x) => { + EventDetails::SsoChangeLoginUrlDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sso_change_login_url_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoChangeLogoutUrlDetails(ref x) => { + EventDetails::SsoChangeLogoutUrlDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sso_change_logout_url_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoChangeSamlIdentityModeDetails(ref x) => { + EventDetails::SsoChangeSamlIdentityModeDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sso_change_saml_identity_mode_details")?; @@ -24624,21 +24624,21 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "sso_remove_cert_details")?; s.end() } - EventDetails::SsoRemoveLoginUrlDetails(ref x) => { + EventDetails::SsoRemoveLoginUrlDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "sso_remove_login_url_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoRemoveLogoutUrlDetails(ref x) => { + EventDetails::SsoRemoveLogoutUrlDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "sso_remove_logout_url_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamFolderChangeStatusDetails(ref x) => { + EventDetails::TeamFolderChangeStatusDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_folder_change_status_details")?; @@ -24651,7 +24651,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "team_folder_create_details")?; s.end() } - EventDetails::TeamFolderDowngradeDetails(ref x) => { + EventDetails::TeamFolderDowngradeDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_folder_downgrade_details")?; @@ -24664,28 +24664,28 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "team_folder_permanently_delete_details")?; s.end() } - EventDetails::TeamFolderRenameDetails(ref x) => { + EventDetails::TeamFolderRenameDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_folder_rename_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamSelectiveSyncSettingsChangedDetails(ref x) => { + EventDetails::TeamSelectiveSyncSettingsChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_selective_sync_settings_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AccountCaptureChangePolicyDetails(ref x) => { + EventDetails::AccountCaptureChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "account_capture_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::AdminEmailRemindersChangedDetails(ref x) => { + EventDetails::AdminEmailRemindersChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "admin_email_reminders_changed_details")?; @@ -24704,56 +24704,56 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "allow_download_enabled_details")?; s.end() } - EventDetails::AppPermissionsChangedDetails(ref x) => { + EventDetails::AppPermissionsChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "app_permissions_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::CameraUploadsPolicyChangedDetails(ref x) => { + EventDetails::CameraUploadsPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "camera_uploads_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::CaptureTranscriptPolicyChangedDetails(ref x) => { + EventDetails::CaptureTranscriptPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "capture_transcript_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ClassificationChangePolicyDetails(ref x) => { + EventDetails::ClassificationChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "classification_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ComputerBackupPolicyChangedDetails(ref x) => { + EventDetails::ComputerBackupPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "computer_backup_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ContentAdministrationPolicyChangedDetails(ref x) => { + EventDetails::ContentAdministrationPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "content_administration_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DataPlacementRestrictionChangePolicyDetails(ref x) => { + EventDetails::DataPlacementRestrictionChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "data_placement_restriction_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DataPlacementRestrictionSatisfyPolicyDetails(ref x) => { + EventDetails::DataPlacementRestrictionSatisfyPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "data_placement_restriction_satisfy_policy_details")?; @@ -24766,28 +24766,28 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "device_approvals_add_exception_details")?; s.end() } - EventDetails::DeviceApprovalsChangeDesktopPolicyDetails(ref x) => { + EventDetails::DeviceApprovalsChangeDesktopPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "device_approvals_change_desktop_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceApprovalsChangeMobilePolicyDetails(ref x) => { + EventDetails::DeviceApprovalsChangeMobilePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "device_approvals_change_mobile_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceApprovalsChangeOverageActionDetails(ref x) => { + EventDetails::DeviceApprovalsChangeOverageActionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "device_approvals_change_overage_action_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::DeviceApprovalsChangeUnlinkActionDetails(ref x) => { + EventDetails::DeviceApprovalsChangeUnlinkActionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "device_approvals_change_unlink_action_details")?; @@ -24812,14 +24812,14 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "directory_restrictions_remove_members_details")?; s.end() } - EventDetails::DropboxPasswordsPolicyChangedDetails(ref x) => { + EventDetails::DropboxPasswordsPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "dropbox_passwords_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::EmailIngestPolicyChangedDetails(ref x) => { + EventDetails::EmailIngestPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "email_ingest_policy_changed_details")?; @@ -24832,7 +24832,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "emm_add_exception_details")?; s.end() } - EventDetails::EmmChangePolicyDetails(ref x) => { + EventDetails::EmmChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "emm_change_policy_details")?; @@ -24845,42 +24845,42 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "emm_remove_exception_details")?; s.end() } - EventDetails::ExtendedVersionHistoryChangePolicyDetails(ref x) => { + EventDetails::ExtendedVersionHistoryChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "extended_version_history_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ExternalDriveBackupPolicyChangedDetails(ref x) => { + EventDetails::ExternalDriveBackupPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "external_drive_backup_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileCommentsChangePolicyDetails(ref x) => { + EventDetails::FileCommentsChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_comments_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileLockingPolicyChangedDetails(ref x) => { + EventDetails::FileLockingPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_locking_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileProviderMigrationPolicyChangedDetails(ref x) => { + EventDetails::FileProviderMigrationPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_provider_migration_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FileRequestsChangePolicyDetails(ref x) => { + EventDetails::FileRequestsChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_requests_change_policy_details")?; @@ -24899,56 +24899,56 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "file_requests_emails_restricted_to_team_only_details")?; s.end() } - EventDetails::FileTransfersPolicyChangedDetails(ref x) => { + EventDetails::FileTransfersPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "file_transfers_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::FolderLinkRestrictionPolicyChangedDetails(ref x) => { + EventDetails::FolderLinkRestrictionPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "folder_link_restriction_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GoogleSsoChangePolicyDetails(ref x) => { + EventDetails::GoogleSsoChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "google_sso_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GroupUserManagementChangePolicyDetails(ref x) => { + EventDetails::GroupUserManagementChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "group_user_management_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::IntegrationPolicyChangedDetails(ref x) => { + EventDetails::IntegrationPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "integration_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::InviteAcceptanceEmailPolicyChangedDetails(ref x) => { + EventDetails::InviteAcceptanceEmailPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "invite_acceptance_email_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberRequestsChangePolicyDetails(ref x) => { + EventDetails::MemberRequestsChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_requests_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberSendInvitePolicyChangedDetails(ref x) => { + EventDetails::MemberSendInvitePolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_send_invite_policy_changed_details")?; @@ -24961,14 +24961,14 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "member_space_limits_add_exception_details")?; s.end() } - EventDetails::MemberSpaceLimitsChangeCapsTypePolicyDetails(ref x) => { + EventDetails::MemberSpaceLimitsChangeCapsTypePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_space_limits_change_caps_type_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MemberSpaceLimitsChangePolicyDetails(ref x) => { + EventDetails::MemberSpaceLimitsChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_space_limits_change_policy_details")?; @@ -24981,63 +24981,63 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "member_space_limits_remove_exception_details")?; s.end() } - EventDetails::MemberSuggestionsChangePolicyDetails(ref x) => { + EventDetails::MemberSuggestionsChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "member_suggestions_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MicrosoftOfficeAddinChangePolicyDetails(ref x) => { + EventDetails::MicrosoftOfficeAddinChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "microsoft_office_addin_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::NetworkControlChangePolicyDetails(ref x) => { + EventDetails::NetworkControlChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "network_control_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperChangeDeploymentPolicyDetails(ref x) => { + EventDetails::PaperChangeDeploymentPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_change_deployment_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperChangeMemberLinkPolicyDetails(ref x) => { + EventDetails::PaperChangeMemberLinkPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "paper_change_member_link_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperChangeMemberPolicyDetails(ref x) => { + EventDetails::PaperChangeMemberPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_change_member_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperChangePolicyDetails(ref x) => { + EventDetails::PaperChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDefaultFolderPolicyChangedDetails(ref x) => { + EventDetails::PaperDefaultFolderPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_default_folder_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PaperDesktopPolicyChangedDetails(ref x) => { + EventDetails::PaperDesktopPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "paper_desktop_policy_changed_details")?; @@ -25056,161 +25056,161 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "paper_enabled_users_group_removal_details")?; s.end() } - EventDetails::PasswordStrengthRequirementsChangePolicyDetails(ref x) => { + EventDetails::PasswordStrengthRequirementsChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "password_strength_requirements_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::PermanentDeleteChangePolicyDetails(ref x) => { + EventDetails::PermanentDeleteChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "permanent_delete_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ResellerSupportChangePolicyDetails(ref x) => { + EventDetails::ResellerSupportChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "reseller_support_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::RewindPolicyChangedDetails(ref x) => { + EventDetails::RewindPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "rewind_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SendForSignaturePolicyChangedDetails(ref x) => { + EventDetails::SendForSignaturePolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "send_for_signature_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharingChangeFolderJoinPolicyDetails(ref x) => { + EventDetails::SharingChangeFolderJoinPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sharing_change_folder_join_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharingChangeLinkAllowChangeExpirationPolicyDetails(ref x) => { + EventDetails::SharingChangeLinkAllowChangeExpirationPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sharing_change_link_allow_change_expiration_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharingChangeLinkDefaultExpirationPolicyDetails(ref x) => { + EventDetails::SharingChangeLinkDefaultExpirationPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sharing_change_link_default_expiration_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharingChangeLinkEnforcePasswordPolicyDetails(ref x) => { + EventDetails::SharingChangeLinkEnforcePasswordPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sharing_change_link_enforce_password_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharingChangeLinkPolicyDetails(ref x) => { + EventDetails::SharingChangeLinkPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sharing_change_link_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SharingChangeMemberPolicyDetails(ref x) => { + EventDetails::SharingChangeMemberPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sharing_change_member_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseChangeDownloadPolicyDetails(ref x) => { + EventDetails::ShowcaseChangeDownloadPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_change_download_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseChangeEnabledPolicyDetails(ref x) => { + EventDetails::ShowcaseChangeEnabledPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_change_enabled_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ShowcaseChangeExternalSharingPolicyDetails(ref x) => { + EventDetails::ShowcaseChangeExternalSharingPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "showcase_change_external_sharing_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SmarterSmartSyncPolicyChangedDetails(ref x) => { + EventDetails::SmarterSmartSyncPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "smarter_smart_sync_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SmartSyncChangePolicyDetails(ref x) => { + EventDetails::SmartSyncChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "smart_sync_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SmartSyncNotOptOutDetails(ref x) => { + EventDetails::SmartSyncNotOptOutDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "smart_sync_not_opt_out_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SmartSyncOptOutDetails(ref x) => { + EventDetails::SmartSyncOptOutDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "smart_sync_opt_out_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::SsoChangePolicyDetails(ref x) => { + EventDetails::SsoChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "sso_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamBrandingPolicyChangedDetails(ref x) => { + EventDetails::TeamBrandingPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_branding_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamExtensionsPolicyChangedDetails(ref x) => { + EventDetails::TeamExtensionsPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_extensions_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamSelectiveSyncPolicyChangedDetails(ref x) => { + EventDetails::TeamSelectiveSyncPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_selective_sync_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamSharingWhitelistSubjectsChangedDetails(ref x) => { + EventDetails::TeamSharingWhitelistSubjectsChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_sharing_whitelist_subjects_changed_details")?; @@ -25223,7 +25223,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "tfa_add_exception_details")?; s.end() } - EventDetails::TfaChangePolicyDetails(ref x) => { + EventDetails::TfaChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "tfa_change_policy_details")?; @@ -25236,42 +25236,42 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "tfa_remove_exception_details")?; s.end() } - EventDetails::TwoAccountChangePolicyDetails(ref x) => { + EventDetails::TwoAccountChangePolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "two_account_change_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ViewerInfoPolicyChangedDetails(ref x) => { + EventDetails::ViewerInfoPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "viewer_info_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::WatermarkingPolicyChangedDetails(ref x) => { + EventDetails::WatermarkingPolicyChangedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "watermarking_policy_changed_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::WebSessionsChangeActiveSessionLimitDetails(ref x) => { + EventDetails::WebSessionsChangeActiveSessionLimitDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "web_sessions_change_active_session_limit_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::WebSessionsChangeFixedLengthPolicyDetails(ref x) => { + EventDetails::WebSessionsChangeFixedLengthPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "web_sessions_change_fixed_length_policy_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::WebSessionsChangeIdleLengthPolicyDetails(ref x) => { + EventDetails::WebSessionsChangeIdleLengthPolicyDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "web_sessions_change_idle_length_policy_details")?; @@ -25290,14 +25290,14 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "data_residency_migration_request_unsuccessful_details")?; s.end() } - EventDetails::TeamMergeFromDetails(ref x) => { + EventDetails::TeamMergeFromDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_from_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeToDetails(ref x) => { + EventDetails::TeamMergeToDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_to_details")?; @@ -25322,7 +25322,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "team_profile_change_background_details")?; s.end() } - EventDetails::TeamProfileChangeDefaultLanguageDetails(ref x) => { + EventDetails::TeamProfileChangeDefaultLanguageDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_profile_change_default_language_details")?; @@ -25335,7 +25335,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "team_profile_change_logo_details")?; s.end() } - EventDetails::TeamProfileChangeNameDetails(ref x) => { + EventDetails::TeamProfileChangeNameDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_profile_change_name_details")?; @@ -25372,7 +25372,7 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "tfa_change_backup_phone_details")?; s.end() } - EventDetails::TfaChangeStatusDetails(ref x) => { + EventDetails::TfaChangeStatusDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "tfa_change_status_details")?; @@ -25397,14 +25397,14 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "tfa_reset_details")?; s.end() } - EventDetails::ChangedEnterpriseAdminRoleDetails(ref x) => { + EventDetails::ChangedEnterpriseAdminRoleDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 4)?; s.serialize_field(".tag", "changed_enterprise_admin_role_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::ChangedEnterpriseConnectedTeamStatusDetails(ref x) => { + EventDetails::ChangedEnterpriseConnectedTeamStatusDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "changed_enterprise_connected_team_status_details")?; @@ -25417,161 +25417,161 @@ impl ::serde::ser::Serialize for EventDetails { s.serialize_field(".tag", "ended_enterprise_admin_session_details")?; s.end() } - EventDetails::EndedEnterpriseAdminSessionDeprecatedDetails(ref x) => { + EventDetails::EndedEnterpriseAdminSessionDeprecatedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "ended_enterprise_admin_session_deprecated_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::EnterpriseSettingsLockingDetails(ref x) => { + EventDetails::EnterpriseSettingsLockingDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 5)?; s.serialize_field(".tag", "enterprise_settings_locking_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::GuestAdminChangeStatusDetails(ref x) => { + EventDetails::GuestAdminChangeStatusDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 7)?; s.serialize_field(".tag", "guest_admin_change_status_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::StartedEnterpriseAdminSessionDetails(ref x) => { + EventDetails::StartedEnterpriseAdminSessionDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "started_enterprise_admin_session_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestAcceptedDetails(ref x) => { + EventDetails::TeamMergeRequestAcceptedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_accepted_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestAcceptedShownToPrimaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestAcceptedShownToPrimaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_merge_request_accepted_shown_to_primary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestAcceptedShownToSecondaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestAcceptedShownToSecondaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_merge_request_accepted_shown_to_secondary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestAutoCanceledDetails(ref x) => { + EventDetails::TeamMergeRequestAutoCanceledDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_auto_canceled_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestCanceledDetails(ref x) => { + EventDetails::TeamMergeRequestCanceledDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_canceled_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestCanceledShownToPrimaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestCanceledShownToPrimaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_merge_request_canceled_shown_to_primary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestCanceledShownToSecondaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestCanceledShownToSecondaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_merge_request_canceled_shown_to_secondary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestExpiredDetails(ref x) => { + EventDetails::TeamMergeRequestExpiredDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_expired_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestExpiredShownToPrimaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestExpiredShownToPrimaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_merge_request_expired_shown_to_primary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestExpiredShownToSecondaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestExpiredShownToSecondaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_expired_shown_to_secondary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestRejectedShownToPrimaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestRejectedShownToPrimaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_merge_request_rejected_shown_to_primary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestRejectedShownToSecondaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestRejectedShownToSecondaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_rejected_shown_to_secondary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestReminderDetails(ref x) => { + EventDetails::TeamMergeRequestReminderDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_reminder_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestReminderShownToPrimaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestReminderShownToPrimaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_merge_request_reminder_shown_to_primary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestReminderShownToSecondaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestReminderShownToSecondaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_reminder_shown_to_secondary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestRevokedDetails(ref x) => { + EventDetails::TeamMergeRequestRevokedDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_revoked_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestSentShownToPrimaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestSentShownToPrimaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 3)?; s.serialize_field(".tag", "team_merge_request_sent_shown_to_primary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::TeamMergeRequestSentShownToSecondaryTeamDetails(ref x) => { + EventDetails::TeamMergeRequestSentShownToSecondaryTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "team_merge_request_sent_shown_to_secondary_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventDetails::MissingDetails(ref x) => { + EventDetails::MissingDetails(x) => { // struct let mut s = serializer.serialize_struct("EventDetails", 2)?; s.serialize_field(".tag", "missing_details")?; @@ -27659,3522 +27659,3522 @@ impl ::serde::ser::Serialize for EventType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - EventType::AdminAlertingAlertStateChanged(ref x) => { + match self { + EventType::AdminAlertingAlertStateChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "admin_alerting_alert_state_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AdminAlertingChangedAlertConfig(ref x) => { + EventType::AdminAlertingChangedAlertConfig(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "admin_alerting_changed_alert_config")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AdminAlertingTriggeredAlert(ref x) => { + EventType::AdminAlertingTriggeredAlert(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "admin_alerting_triggered_alert")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::RansomwareRestoreProcessCompleted(ref x) => { + EventType::RansomwareRestoreProcessCompleted(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "ransomware_restore_process_completed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::RansomwareRestoreProcessStarted(ref x) => { + EventType::RansomwareRestoreProcessStarted(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "ransomware_restore_process_started")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AppBlockedByPermissions(ref x) => { + EventType::AppBlockedByPermissions(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "app_blocked_by_permissions")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AppLinkTeam(ref x) => { + EventType::AppLinkTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "app_link_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AppLinkUser(ref x) => { + EventType::AppLinkUser(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "app_link_user")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AppUnlinkTeam(ref x) => { + EventType::AppUnlinkTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "app_unlink_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AppUnlinkUser(ref x) => { + EventType::AppUnlinkUser(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "app_unlink_user")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::IntegrationConnected(ref x) => { + EventType::IntegrationConnected(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "integration_connected")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::IntegrationDisconnected(ref x) => { + EventType::IntegrationDisconnected(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "integration_disconnected")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileAddComment(ref x) => { + EventType::FileAddComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_add_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileChangeCommentSubscription(ref x) => { + EventType::FileChangeCommentSubscription(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_change_comment_subscription")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileDeleteComment(ref x) => { + EventType::FileDeleteComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_delete_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileEditComment(ref x) => { + EventType::FileEditComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_edit_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileLikeComment(ref x) => { + EventType::FileLikeComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_like_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileResolveComment(ref x) => { + EventType::FileResolveComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_resolve_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileUnlikeComment(ref x) => { + EventType::FileUnlikeComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_unlike_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileUnresolveComment(ref x) => { + EventType::FileUnresolveComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_unresolve_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyAddFolders(ref x) => { + EventType::GovernancePolicyAddFolders(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_add_folders")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyAddFolderFailed(ref x) => { + EventType::GovernancePolicyAddFolderFailed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_add_folder_failed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyContentDisposed(ref x) => { + EventType::GovernancePolicyContentDisposed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_content_disposed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyCreate(ref x) => { + EventType::GovernancePolicyCreate(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_create")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyDelete(ref x) => { + EventType::GovernancePolicyDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyEditDetails(ref x) => { + EventType::GovernancePolicyEditDetails(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_edit_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyEditDuration(ref x) => { + EventType::GovernancePolicyEditDuration(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_edit_duration")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyExportCreated(ref x) => { + EventType::GovernancePolicyExportCreated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_export_created")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyExportRemoved(ref x) => { + EventType::GovernancePolicyExportRemoved(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_export_removed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyRemoveFolders(ref x) => { + EventType::GovernancePolicyRemoveFolders(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_remove_folders")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyReportCreated(ref x) => { + EventType::GovernancePolicyReportCreated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_report_created")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GovernancePolicyZipPartDownloaded(ref x) => { + EventType::GovernancePolicyZipPartDownloaded(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "governance_policy_zip_part_downloaded")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsActivateAHold(ref x) => { + EventType::LegalHoldsActivateAHold(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_activate_a_hold")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsAddMembers(ref x) => { + EventType::LegalHoldsAddMembers(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_add_members")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsChangeHoldDetails(ref x) => { + EventType::LegalHoldsChangeHoldDetails(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_change_hold_details")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsChangeHoldName(ref x) => { + EventType::LegalHoldsChangeHoldName(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_change_hold_name")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsExportAHold(ref x) => { + EventType::LegalHoldsExportAHold(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_export_a_hold")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsExportCancelled(ref x) => { + EventType::LegalHoldsExportCancelled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_export_cancelled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsExportDownloaded(ref x) => { + EventType::LegalHoldsExportDownloaded(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_export_downloaded")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsExportRemoved(ref x) => { + EventType::LegalHoldsExportRemoved(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_export_removed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsReleaseAHold(ref x) => { + EventType::LegalHoldsReleaseAHold(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_release_a_hold")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsRemoveMembers(ref x) => { + EventType::LegalHoldsRemoveMembers(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_remove_members")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LegalHoldsReportAHold(ref x) => { + EventType::LegalHoldsReportAHold(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "legal_holds_report_a_hold")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceChangeIpDesktop(ref x) => { + EventType::DeviceChangeIpDesktop(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_change_ip_desktop")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceChangeIpMobile(ref x) => { + EventType::DeviceChangeIpMobile(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_change_ip_mobile")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceChangeIpWeb(ref x) => { + EventType::DeviceChangeIpWeb(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_change_ip_web")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceDeleteOnUnlinkFail(ref x) => { + EventType::DeviceDeleteOnUnlinkFail(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_delete_on_unlink_fail")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceDeleteOnUnlinkSuccess(ref x) => { + EventType::DeviceDeleteOnUnlinkSuccess(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_delete_on_unlink_success")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceLinkFail(ref x) => { + EventType::DeviceLinkFail(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_link_fail")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceLinkSuccess(ref x) => { + EventType::DeviceLinkSuccess(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_link_success")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceManagementDisabled(ref x) => { + EventType::DeviceManagementDisabled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_management_disabled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceManagementEnabled(ref x) => { + EventType::DeviceManagementEnabled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_management_enabled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceSyncBackupStatusChanged(ref x) => { + EventType::DeviceSyncBackupStatusChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_sync_backup_status_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceUnlink(ref x) => { + EventType::DeviceUnlink(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_unlink")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DropboxPasswordsExported(ref x) => { + EventType::DropboxPasswordsExported(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "dropbox_passwords_exported")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DropboxPasswordsNewDeviceEnrolled(ref x) => { + EventType::DropboxPasswordsNewDeviceEnrolled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "dropbox_passwords_new_device_enrolled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmmRefreshAuthToken(ref x) => { + EventType::EmmRefreshAuthToken(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "emm_refresh_auth_token")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ExternalDriveBackupEligibilityStatusChecked(ref x) => { + EventType::ExternalDriveBackupEligibilityStatusChecked(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "external_drive_backup_eligibility_status_checked")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ExternalDriveBackupStatusChanged(ref x) => { + EventType::ExternalDriveBackupStatusChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "external_drive_backup_status_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AccountCaptureChangeAvailability(ref x) => { + EventType::AccountCaptureChangeAvailability(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "account_capture_change_availability")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AccountCaptureMigrateAccount(ref x) => { + EventType::AccountCaptureMigrateAccount(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "account_capture_migrate_account")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AccountCaptureNotificationEmailsSent(ref x) => { + EventType::AccountCaptureNotificationEmailsSent(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "account_capture_notification_emails_sent")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AccountCaptureRelinquishAccount(ref x) => { + EventType::AccountCaptureRelinquishAccount(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "account_capture_relinquish_account")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DisabledDomainInvites(ref x) => { + EventType::DisabledDomainInvites(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "disabled_domain_invites")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainInvitesApproveRequestToJoinTeam(ref x) => { + EventType::DomainInvitesApproveRequestToJoinTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_invites_approve_request_to_join_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainInvitesDeclineRequestToJoinTeam(ref x) => { + EventType::DomainInvitesDeclineRequestToJoinTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_invites_decline_request_to_join_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainInvitesEmailExistingUsers(ref x) => { + EventType::DomainInvitesEmailExistingUsers(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_invites_email_existing_users")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainInvitesRequestToJoinTeam(ref x) => { + EventType::DomainInvitesRequestToJoinTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_invites_request_to_join_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainInvitesSetInviteNewUserPrefToNo(ref x) => { + EventType::DomainInvitesSetInviteNewUserPrefToNo(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_invites_set_invite_new_user_pref_to_no")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainInvitesSetInviteNewUserPrefToYes(ref x) => { + EventType::DomainInvitesSetInviteNewUserPrefToYes(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_invites_set_invite_new_user_pref_to_yes")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainVerificationAddDomainFail(ref x) => { + EventType::DomainVerificationAddDomainFail(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_verification_add_domain_fail")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainVerificationAddDomainSuccess(ref x) => { + EventType::DomainVerificationAddDomainSuccess(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_verification_add_domain_success")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DomainVerificationRemoveDomain(ref x) => { + EventType::DomainVerificationRemoveDomain(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "domain_verification_remove_domain")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EnabledDomainInvites(ref x) => { + EventType::EnabledDomainInvites(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "enabled_domain_invites")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamEncryptionKeyCancelKeyDeletion(ref x) => { + EventType::TeamEncryptionKeyCancelKeyDeletion(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_encryption_key_cancel_key_deletion")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamEncryptionKeyCreateKey(ref x) => { + EventType::TeamEncryptionKeyCreateKey(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_encryption_key_create_key")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamEncryptionKeyDeleteKey(ref x) => { + EventType::TeamEncryptionKeyDeleteKey(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_encryption_key_delete_key")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamEncryptionKeyDisableKey(ref x) => { + EventType::TeamEncryptionKeyDisableKey(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_encryption_key_disable_key")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamEncryptionKeyEnableKey(ref x) => { + EventType::TeamEncryptionKeyEnableKey(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_encryption_key_enable_key")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamEncryptionKeyRotateKey(ref x) => { + EventType::TeamEncryptionKeyRotateKey(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_encryption_key_rotate_key")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamEncryptionKeyScheduleKeyDeletion(ref x) => { + EventType::TeamEncryptionKeyScheduleKeyDeletion(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_encryption_key_schedule_key_deletion")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ApplyNamingConvention(ref x) => { + EventType::ApplyNamingConvention(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "apply_naming_convention")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::CreateFolder(ref x) => { + EventType::CreateFolder(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "create_folder")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileAdd(ref x) => { + EventType::FileAdd(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_add")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileAddFromAutomation(ref x) => { + EventType::FileAddFromAutomation(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_add_from_automation")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileCopy(ref x) => { + EventType::FileCopy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_copy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileDelete(ref x) => { + EventType::FileDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileDownload(ref x) => { + EventType::FileDownload(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_download")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileEdit(ref x) => { + EventType::FileEdit(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_edit")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileGetCopyReference(ref x) => { + EventType::FileGetCopyReference(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_get_copy_reference")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileLockingLockStatusChanged(ref x) => { + EventType::FileLockingLockStatusChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_locking_lock_status_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileMove(ref x) => { + EventType::FileMove(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_move")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FilePermanentlyDelete(ref x) => { + EventType::FilePermanentlyDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_permanently_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FilePreview(ref x) => { + EventType::FilePreview(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_preview")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRename(ref x) => { + EventType::FileRename(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_rename")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRestore(ref x) => { + EventType::FileRestore(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_restore")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRevert(ref x) => { + EventType::FileRevert(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_revert")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRollbackChanges(ref x) => { + EventType::FileRollbackChanges(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_rollback_changes")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileSaveCopyReference(ref x) => { + EventType::FileSaveCopyReference(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_save_copy_reference")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FolderOverviewDescriptionChanged(ref x) => { + EventType::FolderOverviewDescriptionChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "folder_overview_description_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FolderOverviewItemPinned(ref x) => { + EventType::FolderOverviewItemPinned(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "folder_overview_item_pinned")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FolderOverviewItemUnpinned(ref x) => { + EventType::FolderOverviewItemUnpinned(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "folder_overview_item_unpinned")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ObjectLabelAdded(ref x) => { + EventType::ObjectLabelAdded(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "object_label_added")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ObjectLabelRemoved(ref x) => { + EventType::ObjectLabelRemoved(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "object_label_removed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ObjectLabelUpdatedValue(ref x) => { + EventType::ObjectLabelUpdatedValue(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "object_label_updated_value")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::OrganizeFolderWithTidy(ref x) => { + EventType::OrganizeFolderWithTidy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "organize_folder_with_tidy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ReplayFileDelete(ref x) => { + EventType::ReplayFileDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "replay_file_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::RewindFolder(ref x) => { + EventType::RewindFolder(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "rewind_folder")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::UndoNamingConvention(ref x) => { + EventType::UndoNamingConvention(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "undo_naming_convention")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::UndoOrganizeFolderWithTidy(ref x) => { + EventType::UndoOrganizeFolderWithTidy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "undo_organize_folder_with_tidy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::UserTagsAdded(ref x) => { + EventType::UserTagsAdded(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "user_tags_added")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::UserTagsRemoved(ref x) => { + EventType::UserTagsRemoved(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "user_tags_removed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmailIngestReceiveFile(ref x) => { + EventType::EmailIngestReceiveFile(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "email_ingest_receive_file")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRequestChange(ref x) => { + EventType::FileRequestChange(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_request_change")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRequestClose(ref x) => { + EventType::FileRequestClose(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_request_close")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRequestCreate(ref x) => { + EventType::FileRequestCreate(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_request_create")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRequestDelete(ref x) => { + EventType::FileRequestDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_request_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRequestReceiveFile(ref x) => { + EventType::FileRequestReceiveFile(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_request_receive_file")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupAddExternalId(ref x) => { + EventType::GroupAddExternalId(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_add_external_id")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupAddMember(ref x) => { + EventType::GroupAddMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_add_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupChangeExternalId(ref x) => { + EventType::GroupChangeExternalId(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_change_external_id")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupChangeManagementType(ref x) => { + EventType::GroupChangeManagementType(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_change_management_type")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupChangeMemberRole(ref x) => { + EventType::GroupChangeMemberRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_change_member_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupCreate(ref x) => { + EventType::GroupCreate(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_create")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupDelete(ref x) => { + EventType::GroupDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupDescriptionUpdated(ref x) => { + EventType::GroupDescriptionUpdated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_description_updated")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupJoinPolicyUpdated(ref x) => { + EventType::GroupJoinPolicyUpdated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_join_policy_updated")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupMoved(ref x) => { + EventType::GroupMoved(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_moved")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupRemoveExternalId(ref x) => { + EventType::GroupRemoveExternalId(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_remove_external_id")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupRemoveMember(ref x) => { + EventType::GroupRemoveMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_remove_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupRename(ref x) => { + EventType::GroupRename(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_rename")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AccountLockOrUnlocked(ref x) => { + EventType::AccountLockOrUnlocked(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "account_lock_or_unlocked")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmmError(ref x) => { + EventType::EmmError(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "emm_error")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GuestAdminSignedInViaTrustedTeams(ref x) => { + EventType::GuestAdminSignedInViaTrustedTeams(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "guest_admin_signed_in_via_trusted_teams")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GuestAdminSignedOutViaTrustedTeams(ref x) => { + EventType::GuestAdminSignedOutViaTrustedTeams(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "guest_admin_signed_out_via_trusted_teams")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LoginFail(ref x) => { + EventType::LoginFail(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "login_fail")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::LoginSuccess(ref x) => { + EventType::LoginSuccess(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "login_success")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::Logout(ref x) => { + EventType::Logout(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "logout")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ResellerSupportSessionEnd(ref x) => { + EventType::ResellerSupportSessionEnd(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "reseller_support_session_end")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ResellerSupportSessionStart(ref x) => { + EventType::ResellerSupportSessionStart(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "reseller_support_session_start")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SignInAsSessionEnd(ref x) => { + EventType::SignInAsSessionEnd(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sign_in_as_session_end")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SignInAsSessionStart(ref x) => { + EventType::SignInAsSessionStart(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sign_in_as_session_start")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoError(ref x) => { + EventType::SsoError(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_error")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BackupAdminInvitationSent(ref x) => { + EventType::BackupAdminInvitationSent(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "backup_admin_invitation_sent")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BackupInvitationOpened(ref x) => { + EventType::BackupInvitationOpened(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "backup_invitation_opened")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::CreateTeamInviteLink(ref x) => { + EventType::CreateTeamInviteLink(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "create_team_invite_link")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeleteTeamInviteLink(ref x) => { + EventType::DeleteTeamInviteLink(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "delete_team_invite_link")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberAddExternalId(ref x) => { + EventType::MemberAddExternalId(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_add_external_id")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberAddName(ref x) => { + EventType::MemberAddName(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_add_name")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberChangeAdminRole(ref x) => { + EventType::MemberChangeAdminRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_change_admin_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberChangeEmail(ref x) => { + EventType::MemberChangeEmail(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_change_email")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberChangeExternalId(ref x) => { + EventType::MemberChangeExternalId(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_change_external_id")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberChangeMembershipType(ref x) => { + EventType::MemberChangeMembershipType(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_change_membership_type")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberChangeName(ref x) => { + EventType::MemberChangeName(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_change_name")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberChangeResellerRole(ref x) => { + EventType::MemberChangeResellerRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_change_reseller_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberChangeStatus(ref x) => { + EventType::MemberChangeStatus(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_change_status")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberDeleteManualContacts(ref x) => { + EventType::MemberDeleteManualContacts(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_delete_manual_contacts")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberDeleteProfilePhoto(ref x) => { + EventType::MemberDeleteProfilePhoto(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_delete_profile_photo")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberPermanentlyDeleteAccountContents(ref x) => { + EventType::MemberPermanentlyDeleteAccountContents(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_permanently_delete_account_contents")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberRemoveExternalId(ref x) => { + EventType::MemberRemoveExternalId(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_remove_external_id")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSetProfilePhoto(ref x) => { + EventType::MemberSetProfilePhoto(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_set_profile_photo")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSpaceLimitsAddCustomQuota(ref x) => { + EventType::MemberSpaceLimitsAddCustomQuota(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_space_limits_add_custom_quota")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSpaceLimitsChangeCustomQuota(ref x) => { + EventType::MemberSpaceLimitsChangeCustomQuota(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_space_limits_change_custom_quota")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSpaceLimitsChangeStatus(ref x) => { + EventType::MemberSpaceLimitsChangeStatus(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_space_limits_change_status")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSpaceLimitsRemoveCustomQuota(ref x) => { + EventType::MemberSpaceLimitsRemoveCustomQuota(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_space_limits_remove_custom_quota")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSuggest(ref x) => { + EventType::MemberSuggest(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_suggest")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberTransferAccountContents(ref x) => { + EventType::MemberTransferAccountContents(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_transfer_account_contents")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PendingSecondaryEmailAdded(ref x) => { + EventType::PendingSecondaryEmailAdded(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "pending_secondary_email_added")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SecondaryEmailDeleted(ref x) => { + EventType::SecondaryEmailDeleted(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "secondary_email_deleted")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SecondaryEmailVerified(ref x) => { + EventType::SecondaryEmailVerified(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "secondary_email_verified")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SecondaryMailsPolicyChanged(ref x) => { + EventType::SecondaryMailsPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "secondary_mails_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BinderAddPage(ref x) => { + EventType::BinderAddPage(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "binder_add_page")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BinderAddSection(ref x) => { + EventType::BinderAddSection(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "binder_add_section")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BinderRemovePage(ref x) => { + EventType::BinderRemovePage(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "binder_remove_page")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BinderRemoveSection(ref x) => { + EventType::BinderRemoveSection(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "binder_remove_section")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BinderRenamePage(ref x) => { + EventType::BinderRenamePage(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "binder_rename_page")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BinderRenameSection(ref x) => { + EventType::BinderRenameSection(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "binder_rename_section")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BinderReorderPage(ref x) => { + EventType::BinderReorderPage(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "binder_reorder_page")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::BinderReorderSection(ref x) => { + EventType::BinderReorderSection(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "binder_reorder_section")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentAddMember(ref x) => { + EventType::PaperContentAddMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_add_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentAddToFolder(ref x) => { + EventType::PaperContentAddToFolder(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_add_to_folder")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentArchive(ref x) => { + EventType::PaperContentArchive(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_archive")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentCreate(ref x) => { + EventType::PaperContentCreate(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_create")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentPermanentlyDelete(ref x) => { + EventType::PaperContentPermanentlyDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_permanently_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentRemoveFromFolder(ref x) => { + EventType::PaperContentRemoveFromFolder(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_remove_from_folder")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentRemoveMember(ref x) => { + EventType::PaperContentRemoveMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_remove_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentRename(ref x) => { + EventType::PaperContentRename(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_rename")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperContentRestore(ref x) => { + EventType::PaperContentRestore(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_content_restore")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocAddComment(ref x) => { + EventType::PaperDocAddComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_add_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocChangeMemberRole(ref x) => { + EventType::PaperDocChangeMemberRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_change_member_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocChangeSharingPolicy(ref x) => { + EventType::PaperDocChangeSharingPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_change_sharing_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocChangeSubscription(ref x) => { + EventType::PaperDocChangeSubscription(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_change_subscription")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocDeleted(ref x) => { + EventType::PaperDocDeleted(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_deleted")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocDeleteComment(ref x) => { + EventType::PaperDocDeleteComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_delete_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocDownload(ref x) => { + EventType::PaperDocDownload(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_download")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocEdit(ref x) => { + EventType::PaperDocEdit(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_edit")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocEditComment(ref x) => { + EventType::PaperDocEditComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_edit_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocFollowed(ref x) => { + EventType::PaperDocFollowed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_followed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocMention(ref x) => { + EventType::PaperDocMention(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_mention")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocOwnershipChanged(ref x) => { + EventType::PaperDocOwnershipChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_ownership_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocRequestAccess(ref x) => { + EventType::PaperDocRequestAccess(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_request_access")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocResolveComment(ref x) => { + EventType::PaperDocResolveComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_resolve_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocRevert(ref x) => { + EventType::PaperDocRevert(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_revert")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocSlackShare(ref x) => { + EventType::PaperDocSlackShare(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_slack_share")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocTeamInvite(ref x) => { + EventType::PaperDocTeamInvite(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_team_invite")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocTrashed(ref x) => { + EventType::PaperDocTrashed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_trashed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocUnresolveComment(ref x) => { + EventType::PaperDocUnresolveComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_unresolve_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocUntrashed(ref x) => { + EventType::PaperDocUntrashed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_untrashed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDocView(ref x) => { + EventType::PaperDocView(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_doc_view")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperExternalViewAllow(ref x) => { + EventType::PaperExternalViewAllow(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_external_view_allow")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperExternalViewDefaultTeam(ref x) => { + EventType::PaperExternalViewDefaultTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_external_view_default_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperExternalViewForbid(ref x) => { + EventType::PaperExternalViewForbid(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_external_view_forbid")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperFolderChangeSubscription(ref x) => { + EventType::PaperFolderChangeSubscription(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_folder_change_subscription")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperFolderDeleted(ref x) => { + EventType::PaperFolderDeleted(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_folder_deleted")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperFolderFollowed(ref x) => { + EventType::PaperFolderFollowed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_folder_followed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperFolderTeamInvite(ref x) => { + EventType::PaperFolderTeamInvite(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_folder_team_invite")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperPublishedLinkChangePermission(ref x) => { + EventType::PaperPublishedLinkChangePermission(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_published_link_change_permission")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperPublishedLinkCreate(ref x) => { + EventType::PaperPublishedLinkCreate(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_published_link_create")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperPublishedLinkDisabled(ref x) => { + EventType::PaperPublishedLinkDisabled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_published_link_disabled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperPublishedLinkView(ref x) => { + EventType::PaperPublishedLinkView(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_published_link_view")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PasswordChange(ref x) => { + EventType::PasswordChange(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "password_change")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PasswordReset(ref x) => { + EventType::PasswordReset(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "password_reset")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PasswordResetAll(ref x) => { + EventType::PasswordResetAll(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "password_reset_all")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ClassificationCreateReport(ref x) => { + EventType::ClassificationCreateReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "classification_create_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ClassificationCreateReportFail(ref x) => { + EventType::ClassificationCreateReportFail(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "classification_create_report_fail")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmmCreateExceptionsReport(ref x) => { + EventType::EmmCreateExceptionsReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "emm_create_exceptions_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmmCreateUsageReport(ref x) => { + EventType::EmmCreateUsageReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "emm_create_usage_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ExportMembersReport(ref x) => { + EventType::ExportMembersReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "export_members_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ExportMembersReportFail(ref x) => { + EventType::ExportMembersReportFail(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "export_members_report_fail")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ExternalSharingCreateReport(ref x) => { + EventType::ExternalSharingCreateReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "external_sharing_create_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ExternalSharingReportFailed(ref x) => { + EventType::ExternalSharingReportFailed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "external_sharing_report_failed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoExpirationLinkGenCreateReport(ref x) => { + EventType::NoExpirationLinkGenCreateReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "no_expiration_link_gen_create_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoExpirationLinkGenReportFailed(ref x) => { + EventType::NoExpirationLinkGenReportFailed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "no_expiration_link_gen_report_failed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoPasswordLinkGenCreateReport(ref x) => { + EventType::NoPasswordLinkGenCreateReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "no_password_link_gen_create_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoPasswordLinkGenReportFailed(ref x) => { + EventType::NoPasswordLinkGenReportFailed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "no_password_link_gen_report_failed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoPasswordLinkViewCreateReport(ref x) => { + EventType::NoPasswordLinkViewCreateReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "no_password_link_view_create_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoPasswordLinkViewReportFailed(ref x) => { + EventType::NoPasswordLinkViewReportFailed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "no_password_link_view_report_failed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::OutdatedLinkViewCreateReport(ref x) => { + EventType::OutdatedLinkViewCreateReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "outdated_link_view_create_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::OutdatedLinkViewReportFailed(ref x) => { + EventType::OutdatedLinkViewReportFailed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "outdated_link_view_report_failed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperAdminExportStart(ref x) => { + EventType::PaperAdminExportStart(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_admin_export_start")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::RansomwareAlertCreateReport(ref x) => { + EventType::RansomwareAlertCreateReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "ransomware_alert_create_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::RansomwareAlertCreateReportFailed(ref x) => { + EventType::RansomwareAlertCreateReportFailed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "ransomware_alert_create_report_failed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SmartSyncCreateAdminPrivilegeReport(ref x) => { + EventType::SmartSyncCreateAdminPrivilegeReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "smart_sync_create_admin_privilege_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamActivityCreateReport(ref x) => { + EventType::TeamActivityCreateReport(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_activity_create_report")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamActivityCreateReportFail(ref x) => { + EventType::TeamActivityCreateReportFail(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_activity_create_report_fail")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::CollectionShare(ref x) => { + EventType::CollectionShare(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "collection_share")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileTransfersFileAdd(ref x) => { + EventType::FileTransfersFileAdd(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_transfers_file_add")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileTransfersTransferDelete(ref x) => { + EventType::FileTransfersTransferDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_transfers_transfer_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileTransfersTransferDownload(ref x) => { + EventType::FileTransfersTransferDownload(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_transfers_transfer_download")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileTransfersTransferSend(ref x) => { + EventType::FileTransfersTransferSend(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_transfers_transfer_send")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileTransfersTransferView(ref x) => { + EventType::FileTransfersTransferView(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_transfers_transfer_view")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoteAclInviteOnly(ref x) => { + EventType::NoteAclInviteOnly(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "note_acl_invite_only")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoteAclLink(ref x) => { + EventType::NoteAclLink(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "note_acl_link")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoteAclTeamLink(ref x) => { + EventType::NoteAclTeamLink(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "note_acl_team_link")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoteShared(ref x) => { + EventType::NoteShared(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "note_shared")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NoteShareReceive(ref x) => { + EventType::NoteShareReceive(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "note_share_receive")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::OpenNoteShared(ref x) => { + EventType::OpenNoteShared(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "open_note_shared")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ReplayFileSharedLinkCreated(ref x) => { + EventType::ReplayFileSharedLinkCreated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "replay_file_shared_link_created")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ReplayFileSharedLinkModified(ref x) => { + EventType::ReplayFileSharedLinkModified(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "replay_file_shared_link_modified")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ReplayProjectTeamAdd(ref x) => { + EventType::ReplayProjectTeamAdd(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "replay_project_team_add")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ReplayProjectTeamDelete(ref x) => { + EventType::ReplayProjectTeamDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "replay_project_team_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfAddGroup(ref x) => { + EventType::SfAddGroup(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_add_group")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfAllowNonMembersToViewSharedLinks(ref x) => { + EventType::SfAllowNonMembersToViewSharedLinks(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_allow_non_members_to_view_shared_links")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfExternalInviteWarn(ref x) => { + EventType::SfExternalInviteWarn(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_external_invite_warn")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfFbInvite(ref x) => { + EventType::SfFbInvite(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_fb_invite")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfFbInviteChangeRole(ref x) => { + EventType::SfFbInviteChangeRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_fb_invite_change_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfFbUninvite(ref x) => { + EventType::SfFbUninvite(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_fb_uninvite")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfInviteGroup(ref x) => { + EventType::SfInviteGroup(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_invite_group")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfTeamGrantAccess(ref x) => { + EventType::SfTeamGrantAccess(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_team_grant_access")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfTeamInvite(ref x) => { + EventType::SfTeamInvite(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_team_invite")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfTeamInviteChangeRole(ref x) => { + EventType::SfTeamInviteChangeRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_team_invite_change_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfTeamJoin(ref x) => { + EventType::SfTeamJoin(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_team_join")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfTeamJoinFromOobLink(ref x) => { + EventType::SfTeamJoinFromOobLink(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_team_join_from_oob_link")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SfTeamUninvite(ref x) => { + EventType::SfTeamUninvite(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sf_team_uninvite")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentAddInvitees(ref x) => { + EventType::SharedContentAddInvitees(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_add_invitees")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentAddLinkExpiry(ref x) => { + EventType::SharedContentAddLinkExpiry(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_add_link_expiry")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentAddLinkPassword(ref x) => { + EventType::SharedContentAddLinkPassword(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_add_link_password")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentAddMember(ref x) => { + EventType::SharedContentAddMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_add_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentChangeDownloadsPolicy(ref x) => { + EventType::SharedContentChangeDownloadsPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_change_downloads_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentChangeInviteeRole(ref x) => { + EventType::SharedContentChangeInviteeRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_change_invitee_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentChangeLinkAudience(ref x) => { + EventType::SharedContentChangeLinkAudience(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_change_link_audience")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentChangeLinkExpiry(ref x) => { + EventType::SharedContentChangeLinkExpiry(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_change_link_expiry")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentChangeLinkPassword(ref x) => { + EventType::SharedContentChangeLinkPassword(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_change_link_password")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentChangeMemberRole(ref x) => { + EventType::SharedContentChangeMemberRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_change_member_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentChangeViewerInfoPolicy(ref x) => { + EventType::SharedContentChangeViewerInfoPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_change_viewer_info_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentClaimInvitation(ref x) => { + EventType::SharedContentClaimInvitation(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_claim_invitation")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentCopy(ref x) => { + EventType::SharedContentCopy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_copy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentDownload(ref x) => { + EventType::SharedContentDownload(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_download")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentRelinquishMembership(ref x) => { + EventType::SharedContentRelinquishMembership(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_relinquish_membership")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentRemoveInvitees(ref x) => { + EventType::SharedContentRemoveInvitees(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_remove_invitees")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentRemoveLinkExpiry(ref x) => { + EventType::SharedContentRemoveLinkExpiry(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_remove_link_expiry")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentRemoveLinkPassword(ref x) => { + EventType::SharedContentRemoveLinkPassword(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_remove_link_password")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentRemoveMember(ref x) => { + EventType::SharedContentRemoveMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_remove_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentRequestAccess(ref x) => { + EventType::SharedContentRequestAccess(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_request_access")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentRestoreInvitees(ref x) => { + EventType::SharedContentRestoreInvitees(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_restore_invitees")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentRestoreMember(ref x) => { + EventType::SharedContentRestoreMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_restore_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentUnshare(ref x) => { + EventType::SharedContentUnshare(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_unshare")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedContentView(ref x) => { + EventType::SharedContentView(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_content_view")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderChangeLinkPolicy(ref x) => { + EventType::SharedFolderChangeLinkPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_change_link_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderChangeMembersInheritancePolicy(ref x) => { + EventType::SharedFolderChangeMembersInheritancePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_change_members_inheritance_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderChangeMembersManagementPolicy(ref x) => { + EventType::SharedFolderChangeMembersManagementPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_change_members_management_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderChangeMembersPolicy(ref x) => { + EventType::SharedFolderChangeMembersPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_change_members_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderCreate(ref x) => { + EventType::SharedFolderCreate(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_create")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderDeclineInvitation(ref x) => { + EventType::SharedFolderDeclineInvitation(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_decline_invitation")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderMount(ref x) => { + EventType::SharedFolderMount(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_mount")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderNest(ref x) => { + EventType::SharedFolderNest(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_nest")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderTransferOwnership(ref x) => { + EventType::SharedFolderTransferOwnership(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_transfer_ownership")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedFolderUnmount(ref x) => { + EventType::SharedFolderUnmount(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_folder_unmount")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkAddExpiry(ref x) => { + EventType::SharedLinkAddExpiry(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_add_expiry")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkChangeExpiry(ref x) => { + EventType::SharedLinkChangeExpiry(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_change_expiry")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkChangeVisibility(ref x) => { + EventType::SharedLinkChangeVisibility(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_change_visibility")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkCopy(ref x) => { + EventType::SharedLinkCopy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_copy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkCreate(ref x) => { + EventType::SharedLinkCreate(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_create")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkDisable(ref x) => { + EventType::SharedLinkDisable(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_disable")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkDownload(ref x) => { + EventType::SharedLinkDownload(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_download")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkRemoveExpiry(ref x) => { + EventType::SharedLinkRemoveExpiry(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_remove_expiry")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsAddExpiration(ref x) => { + EventType::SharedLinkSettingsAddExpiration(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_add_expiration")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsAddPassword(ref x) => { + EventType::SharedLinkSettingsAddPassword(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_add_password")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsAllowDownloadDisabled(ref x) => { + EventType::SharedLinkSettingsAllowDownloadDisabled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_allow_download_disabled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsAllowDownloadEnabled(ref x) => { + EventType::SharedLinkSettingsAllowDownloadEnabled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_allow_download_enabled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsChangeAudience(ref x) => { + EventType::SharedLinkSettingsChangeAudience(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_change_audience")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsChangeExpiration(ref x) => { + EventType::SharedLinkSettingsChangeExpiration(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_change_expiration")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsChangePassword(ref x) => { + EventType::SharedLinkSettingsChangePassword(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_change_password")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsRemoveExpiration(ref x) => { + EventType::SharedLinkSettingsRemoveExpiration(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_remove_expiration")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkSettingsRemovePassword(ref x) => { + EventType::SharedLinkSettingsRemovePassword(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_settings_remove_password")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkShare(ref x) => { + EventType::SharedLinkShare(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_share")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedLinkView(ref x) => { + EventType::SharedLinkView(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_link_view")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharedNoteOpened(ref x) => { + EventType::SharedNoteOpened(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shared_note_opened")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShmodelDisableDownloads(ref x) => { + EventType::ShmodelDisableDownloads(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shmodel_disable_downloads")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShmodelEnableDownloads(ref x) => { + EventType::ShmodelEnableDownloads(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shmodel_enable_downloads")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShmodelGroupShare(ref x) => { + EventType::ShmodelGroupShare(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "shmodel_group_share")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseAccessGranted(ref x) => { + EventType::ShowcaseAccessGranted(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_access_granted")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseAddMember(ref x) => { + EventType::ShowcaseAddMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_add_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseArchived(ref x) => { + EventType::ShowcaseArchived(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_archived")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseCreated(ref x) => { + EventType::ShowcaseCreated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_created")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseDeleteComment(ref x) => { + EventType::ShowcaseDeleteComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_delete_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseEdited(ref x) => { + EventType::ShowcaseEdited(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_edited")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseEditComment(ref x) => { + EventType::ShowcaseEditComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_edit_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseFileAdded(ref x) => { + EventType::ShowcaseFileAdded(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_file_added")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseFileDownload(ref x) => { + EventType::ShowcaseFileDownload(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_file_download")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseFileRemoved(ref x) => { + EventType::ShowcaseFileRemoved(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_file_removed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseFileView(ref x) => { + EventType::ShowcaseFileView(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_file_view")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcasePermanentlyDeleted(ref x) => { + EventType::ShowcasePermanentlyDeleted(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_permanently_deleted")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcasePostComment(ref x) => { + EventType::ShowcasePostComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_post_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseRemoveMember(ref x) => { + EventType::ShowcaseRemoveMember(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_remove_member")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseRenamed(ref x) => { + EventType::ShowcaseRenamed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_renamed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseRequestAccess(ref x) => { + EventType::ShowcaseRequestAccess(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_request_access")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseResolveComment(ref x) => { + EventType::ShowcaseResolveComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_resolve_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseRestored(ref x) => { + EventType::ShowcaseRestored(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_restored")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseTrashed(ref x) => { + EventType::ShowcaseTrashed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_trashed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseTrashedDeprecated(ref x) => { + EventType::ShowcaseTrashedDeprecated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_trashed_deprecated")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseUnresolveComment(ref x) => { + EventType::ShowcaseUnresolveComment(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_unresolve_comment")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseUntrashed(ref x) => { + EventType::ShowcaseUntrashed(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_untrashed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseUntrashedDeprecated(ref x) => { + EventType::ShowcaseUntrashedDeprecated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_untrashed_deprecated")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseView(ref x) => { + EventType::ShowcaseView(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_view")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoAddCert(ref x) => { + EventType::SsoAddCert(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_add_cert")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoAddLoginUrl(ref x) => { + EventType::SsoAddLoginUrl(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_add_login_url")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoAddLogoutUrl(ref x) => { + EventType::SsoAddLogoutUrl(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_add_logout_url")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoChangeCert(ref x) => { + EventType::SsoChangeCert(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_change_cert")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoChangeLoginUrl(ref x) => { + EventType::SsoChangeLoginUrl(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_change_login_url")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoChangeLogoutUrl(ref x) => { + EventType::SsoChangeLogoutUrl(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_change_logout_url")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoChangeSamlIdentityMode(ref x) => { + EventType::SsoChangeSamlIdentityMode(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_change_saml_identity_mode")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoRemoveCert(ref x) => { + EventType::SsoRemoveCert(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_remove_cert")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoRemoveLoginUrl(ref x) => { + EventType::SsoRemoveLoginUrl(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_remove_login_url")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoRemoveLogoutUrl(ref x) => { + EventType::SsoRemoveLogoutUrl(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_remove_logout_url")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamFolderChangeStatus(ref x) => { + EventType::TeamFolderChangeStatus(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_folder_change_status")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamFolderCreate(ref x) => { + EventType::TeamFolderCreate(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_folder_create")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamFolderDowngrade(ref x) => { + EventType::TeamFolderDowngrade(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_folder_downgrade")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamFolderPermanentlyDelete(ref x) => { + EventType::TeamFolderPermanentlyDelete(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_folder_permanently_delete")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamFolderRename(ref x) => { + EventType::TeamFolderRename(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_folder_rename")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamSelectiveSyncSettingsChanged(ref x) => { + EventType::TeamSelectiveSyncSettingsChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_selective_sync_settings_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AccountCaptureChangePolicy(ref x) => { + EventType::AccountCaptureChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "account_capture_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AdminEmailRemindersChanged(ref x) => { + EventType::AdminEmailRemindersChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "admin_email_reminders_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AllowDownloadDisabled(ref x) => { + EventType::AllowDownloadDisabled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "allow_download_disabled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AllowDownloadEnabled(ref x) => { + EventType::AllowDownloadEnabled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "allow_download_enabled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::AppPermissionsChanged(ref x) => { + EventType::AppPermissionsChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "app_permissions_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::CameraUploadsPolicyChanged(ref x) => { + EventType::CameraUploadsPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "camera_uploads_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::CaptureTranscriptPolicyChanged(ref x) => { + EventType::CaptureTranscriptPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "capture_transcript_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ClassificationChangePolicy(ref x) => { + EventType::ClassificationChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "classification_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ComputerBackupPolicyChanged(ref x) => { + EventType::ComputerBackupPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "computer_backup_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ContentAdministrationPolicyChanged(ref x) => { + EventType::ContentAdministrationPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "content_administration_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DataPlacementRestrictionChangePolicy(ref x) => { + EventType::DataPlacementRestrictionChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "data_placement_restriction_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DataPlacementRestrictionSatisfyPolicy(ref x) => { + EventType::DataPlacementRestrictionSatisfyPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "data_placement_restriction_satisfy_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceApprovalsAddException(ref x) => { + EventType::DeviceApprovalsAddException(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_approvals_add_exception")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceApprovalsChangeDesktopPolicy(ref x) => { + EventType::DeviceApprovalsChangeDesktopPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_approvals_change_desktop_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceApprovalsChangeMobilePolicy(ref x) => { + EventType::DeviceApprovalsChangeMobilePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_approvals_change_mobile_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceApprovalsChangeOverageAction(ref x) => { + EventType::DeviceApprovalsChangeOverageAction(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_approvals_change_overage_action")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceApprovalsChangeUnlinkAction(ref x) => { + EventType::DeviceApprovalsChangeUnlinkAction(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_approvals_change_unlink_action")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DeviceApprovalsRemoveException(ref x) => { + EventType::DeviceApprovalsRemoveException(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "device_approvals_remove_exception")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DirectoryRestrictionsAddMembers(ref x) => { + EventType::DirectoryRestrictionsAddMembers(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "directory_restrictions_add_members")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DirectoryRestrictionsRemoveMembers(ref x) => { + EventType::DirectoryRestrictionsRemoveMembers(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "directory_restrictions_remove_members")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DropboxPasswordsPolicyChanged(ref x) => { + EventType::DropboxPasswordsPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "dropbox_passwords_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmailIngestPolicyChanged(ref x) => { + EventType::EmailIngestPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "email_ingest_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmmAddException(ref x) => { + EventType::EmmAddException(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "emm_add_exception")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmmChangePolicy(ref x) => { + EventType::EmmChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "emm_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EmmRemoveException(ref x) => { + EventType::EmmRemoveException(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "emm_remove_exception")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ExtendedVersionHistoryChangePolicy(ref x) => { + EventType::ExtendedVersionHistoryChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "extended_version_history_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ExternalDriveBackupPolicyChanged(ref x) => { + EventType::ExternalDriveBackupPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "external_drive_backup_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileCommentsChangePolicy(ref x) => { + EventType::FileCommentsChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_comments_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileLockingPolicyChanged(ref x) => { + EventType::FileLockingPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_locking_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileProviderMigrationPolicyChanged(ref x) => { + EventType::FileProviderMigrationPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_provider_migration_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRequestsChangePolicy(ref x) => { + EventType::FileRequestsChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_requests_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRequestsEmailsEnabled(ref x) => { + EventType::FileRequestsEmailsEnabled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_requests_emails_enabled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileRequestsEmailsRestrictedToTeamOnly(ref x) => { + EventType::FileRequestsEmailsRestrictedToTeamOnly(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_requests_emails_restricted_to_team_only")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FileTransfersPolicyChanged(ref x) => { + EventType::FileTransfersPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "file_transfers_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::FolderLinkRestrictionPolicyChanged(ref x) => { + EventType::FolderLinkRestrictionPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "folder_link_restriction_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GoogleSsoChangePolicy(ref x) => { + EventType::GoogleSsoChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "google_sso_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GroupUserManagementChangePolicy(ref x) => { + EventType::GroupUserManagementChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "group_user_management_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::IntegrationPolicyChanged(ref x) => { + EventType::IntegrationPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "integration_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::InviteAcceptanceEmailPolicyChanged(ref x) => { + EventType::InviteAcceptanceEmailPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "invite_acceptance_email_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberRequestsChangePolicy(ref x) => { + EventType::MemberRequestsChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_requests_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSendInvitePolicyChanged(ref x) => { + EventType::MemberSendInvitePolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_send_invite_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSpaceLimitsAddException(ref x) => { + EventType::MemberSpaceLimitsAddException(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_space_limits_add_exception")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSpaceLimitsChangeCapsTypePolicy(ref x) => { + EventType::MemberSpaceLimitsChangeCapsTypePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_space_limits_change_caps_type_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSpaceLimitsChangePolicy(ref x) => { + EventType::MemberSpaceLimitsChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_space_limits_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSpaceLimitsRemoveException(ref x) => { + EventType::MemberSpaceLimitsRemoveException(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_space_limits_remove_exception")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MemberSuggestionsChangePolicy(ref x) => { + EventType::MemberSuggestionsChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "member_suggestions_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::MicrosoftOfficeAddinChangePolicy(ref x) => { + EventType::MicrosoftOfficeAddinChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "microsoft_office_addin_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::NetworkControlChangePolicy(ref x) => { + EventType::NetworkControlChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "network_control_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperChangeDeploymentPolicy(ref x) => { + EventType::PaperChangeDeploymentPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_change_deployment_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperChangeMemberLinkPolicy(ref x) => { + EventType::PaperChangeMemberLinkPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_change_member_link_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperChangeMemberPolicy(ref x) => { + EventType::PaperChangeMemberPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_change_member_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperChangePolicy(ref x) => { + EventType::PaperChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDefaultFolderPolicyChanged(ref x) => { + EventType::PaperDefaultFolderPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_default_folder_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperDesktopPolicyChanged(ref x) => { + EventType::PaperDesktopPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_desktop_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperEnabledUsersGroupAddition(ref x) => { + EventType::PaperEnabledUsersGroupAddition(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_enabled_users_group_addition")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PaperEnabledUsersGroupRemoval(ref x) => { + EventType::PaperEnabledUsersGroupRemoval(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "paper_enabled_users_group_removal")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PasswordStrengthRequirementsChangePolicy(ref x) => { + EventType::PasswordStrengthRequirementsChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "password_strength_requirements_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::PermanentDeleteChangePolicy(ref x) => { + EventType::PermanentDeleteChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "permanent_delete_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ResellerSupportChangePolicy(ref x) => { + EventType::ResellerSupportChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "reseller_support_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::RewindPolicyChanged(ref x) => { + EventType::RewindPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "rewind_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SendForSignaturePolicyChanged(ref x) => { + EventType::SendForSignaturePolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "send_for_signature_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharingChangeFolderJoinPolicy(ref x) => { + EventType::SharingChangeFolderJoinPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sharing_change_folder_join_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharingChangeLinkAllowChangeExpirationPolicy(ref x) => { + EventType::SharingChangeLinkAllowChangeExpirationPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sharing_change_link_allow_change_expiration_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharingChangeLinkDefaultExpirationPolicy(ref x) => { + EventType::SharingChangeLinkDefaultExpirationPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sharing_change_link_default_expiration_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharingChangeLinkEnforcePasswordPolicy(ref x) => { + EventType::SharingChangeLinkEnforcePasswordPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sharing_change_link_enforce_password_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharingChangeLinkPolicy(ref x) => { + EventType::SharingChangeLinkPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sharing_change_link_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SharingChangeMemberPolicy(ref x) => { + EventType::SharingChangeMemberPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sharing_change_member_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseChangeDownloadPolicy(ref x) => { + EventType::ShowcaseChangeDownloadPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_change_download_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseChangeEnabledPolicy(ref x) => { + EventType::ShowcaseChangeEnabledPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_change_enabled_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ShowcaseChangeExternalSharingPolicy(ref x) => { + EventType::ShowcaseChangeExternalSharingPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "showcase_change_external_sharing_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SmarterSmartSyncPolicyChanged(ref x) => { + EventType::SmarterSmartSyncPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "smarter_smart_sync_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SmartSyncChangePolicy(ref x) => { + EventType::SmartSyncChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "smart_sync_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SmartSyncNotOptOut(ref x) => { + EventType::SmartSyncNotOptOut(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "smart_sync_not_opt_out")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SmartSyncOptOut(ref x) => { + EventType::SmartSyncOptOut(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "smart_sync_opt_out")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::SsoChangePolicy(ref x) => { + EventType::SsoChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "sso_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamBrandingPolicyChanged(ref x) => { + EventType::TeamBrandingPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_branding_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamExtensionsPolicyChanged(ref x) => { + EventType::TeamExtensionsPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_extensions_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamSelectiveSyncPolicyChanged(ref x) => { + EventType::TeamSelectiveSyncPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_selective_sync_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamSharingWhitelistSubjectsChanged(ref x) => { + EventType::TeamSharingWhitelistSubjectsChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_sharing_whitelist_subjects_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaAddException(ref x) => { + EventType::TfaAddException(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_add_exception")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaChangePolicy(ref x) => { + EventType::TfaChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaRemoveException(ref x) => { + EventType::TfaRemoveException(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_remove_exception")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TwoAccountChangePolicy(ref x) => { + EventType::TwoAccountChangePolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "two_account_change_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ViewerInfoPolicyChanged(ref x) => { + EventType::ViewerInfoPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "viewer_info_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::WatermarkingPolicyChanged(ref x) => { + EventType::WatermarkingPolicyChanged(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "watermarking_policy_changed")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::WebSessionsChangeActiveSessionLimit(ref x) => { + EventType::WebSessionsChangeActiveSessionLimit(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "web_sessions_change_active_session_limit")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::WebSessionsChangeFixedLengthPolicy(ref x) => { + EventType::WebSessionsChangeFixedLengthPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "web_sessions_change_fixed_length_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::WebSessionsChangeIdleLengthPolicy(ref x) => { + EventType::WebSessionsChangeIdleLengthPolicy(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "web_sessions_change_idle_length_policy")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DataResidencyMigrationRequestSuccessful(ref x) => { + EventType::DataResidencyMigrationRequestSuccessful(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "data_residency_migration_request_successful")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::DataResidencyMigrationRequestUnsuccessful(ref x) => { + EventType::DataResidencyMigrationRequestUnsuccessful(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "data_residency_migration_request_unsuccessful")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeFrom(ref x) => { + EventType::TeamMergeFrom(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_from")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeTo(ref x) => { + EventType::TeamMergeTo(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_to")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamProfileAddBackground(ref x) => { + EventType::TeamProfileAddBackground(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_profile_add_background")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamProfileAddLogo(ref x) => { + EventType::TeamProfileAddLogo(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_profile_add_logo")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamProfileChangeBackground(ref x) => { + EventType::TeamProfileChangeBackground(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_profile_change_background")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamProfileChangeDefaultLanguage(ref x) => { + EventType::TeamProfileChangeDefaultLanguage(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_profile_change_default_language")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamProfileChangeLogo(ref x) => { + EventType::TeamProfileChangeLogo(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_profile_change_logo")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamProfileChangeName(ref x) => { + EventType::TeamProfileChangeName(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_profile_change_name")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamProfileRemoveBackground(ref x) => { + EventType::TeamProfileRemoveBackground(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_profile_remove_background")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamProfileRemoveLogo(ref x) => { + EventType::TeamProfileRemoveLogo(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_profile_remove_logo")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaAddBackupPhone(ref x) => { + EventType::TfaAddBackupPhone(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_add_backup_phone")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaAddSecurityKey(ref x) => { + EventType::TfaAddSecurityKey(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_add_security_key")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaChangeBackupPhone(ref x) => { + EventType::TfaChangeBackupPhone(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_change_backup_phone")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaChangeStatus(ref x) => { + EventType::TfaChangeStatus(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_change_status")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaRemoveBackupPhone(ref x) => { + EventType::TfaRemoveBackupPhone(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_remove_backup_phone")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaRemoveSecurityKey(ref x) => { + EventType::TfaRemoveSecurityKey(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_remove_security_key")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TfaReset(ref x) => { + EventType::TfaReset(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "tfa_reset")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ChangedEnterpriseAdminRole(ref x) => { + EventType::ChangedEnterpriseAdminRole(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "changed_enterprise_admin_role")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::ChangedEnterpriseConnectedTeamStatus(ref x) => { + EventType::ChangedEnterpriseConnectedTeamStatus(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "changed_enterprise_connected_team_status")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EndedEnterpriseAdminSession(ref x) => { + EventType::EndedEnterpriseAdminSession(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "ended_enterprise_admin_session")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EndedEnterpriseAdminSessionDeprecated(ref x) => { + EventType::EndedEnterpriseAdminSessionDeprecated(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "ended_enterprise_admin_session_deprecated")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::EnterpriseSettingsLocking(ref x) => { + EventType::EnterpriseSettingsLocking(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "enterprise_settings_locking")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::GuestAdminChangeStatus(ref x) => { + EventType::GuestAdminChangeStatus(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "guest_admin_change_status")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::StartedEnterpriseAdminSession(ref x) => { + EventType::StartedEnterpriseAdminSession(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "started_enterprise_admin_session")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestAccepted(ref x) => { + EventType::TeamMergeRequestAccepted(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_accepted")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestAcceptedShownToPrimaryTeam(ref x) => { + EventType::TeamMergeRequestAcceptedShownToPrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_accepted_shown_to_primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestAcceptedShownToSecondaryTeam(ref x) => { + EventType::TeamMergeRequestAcceptedShownToSecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_accepted_shown_to_secondary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestAutoCanceled(ref x) => { + EventType::TeamMergeRequestAutoCanceled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_auto_canceled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestCanceled(ref x) => { + EventType::TeamMergeRequestCanceled(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_canceled")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestCanceledShownToPrimaryTeam(ref x) => { + EventType::TeamMergeRequestCanceledShownToPrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_canceled_shown_to_primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestCanceledShownToSecondaryTeam(ref x) => { + EventType::TeamMergeRequestCanceledShownToSecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_canceled_shown_to_secondary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestExpired(ref x) => { + EventType::TeamMergeRequestExpired(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_expired")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestExpiredShownToPrimaryTeam(ref x) => { + EventType::TeamMergeRequestExpiredShownToPrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_expired_shown_to_primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestExpiredShownToSecondaryTeam(ref x) => { + EventType::TeamMergeRequestExpiredShownToSecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_expired_shown_to_secondary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestRejectedShownToPrimaryTeam(ref x) => { + EventType::TeamMergeRequestRejectedShownToPrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_rejected_shown_to_primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestRejectedShownToSecondaryTeam(ref x) => { + EventType::TeamMergeRequestRejectedShownToSecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_rejected_shown_to_secondary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestReminder(ref x) => { + EventType::TeamMergeRequestReminder(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_reminder")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestReminderShownToPrimaryTeam(ref x) => { + EventType::TeamMergeRequestReminderShownToPrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_reminder_shown_to_primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestReminderShownToSecondaryTeam(ref x) => { + EventType::TeamMergeRequestReminderShownToSecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_reminder_shown_to_secondary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestRevoked(ref x) => { + EventType::TeamMergeRequestRevoked(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_revoked")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestSentShownToPrimaryTeam(ref x) => { + EventType::TeamMergeRequestSentShownToPrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_sent_shown_to_primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - EventType::TeamMergeRequestSentShownToSecondaryTeam(ref x) => { + EventType::TeamMergeRequestSentShownToSecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("EventType", 2)?; s.serialize_field(".tag", "team_merge_request_sent_shown_to_secondary_team")?; @@ -33262,7 +33262,7 @@ impl ::serde::ser::Serialize for EventTypeArg { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { EventTypeArg::AdminAlertingAlertStateChanged => { // unit let mut s = serializer.serialize_struct("EventTypeArg", 1)?; @@ -36855,7 +36855,7 @@ impl ::serde::ser::Serialize for ExtendedVersionHistoryPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExtendedVersionHistoryPolicy::ExplicitlyLimited => { // unit let mut s = serializer.serialize_struct("ExtendedVersionHistoryPolicy", 1)?; @@ -36931,7 +36931,7 @@ impl ::serde::ser::Serialize for ExternalDriveBackupEligibilityStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExternalDriveBackupEligibilityStatus::ExceedLicenseCap => { // unit let mut s = serializer.serialize_struct("ExternalDriveBackupEligibilityStatus", 1)?; @@ -37210,7 +37210,7 @@ impl ::serde::ser::Serialize for ExternalDriveBackupPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExternalDriveBackupPolicy::Default => { // unit let mut s = serializer.serialize_struct("ExternalDriveBackupPolicy", 1)?; @@ -37490,7 +37490,7 @@ impl ::serde::ser::Serialize for ExternalDriveBackupStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExternalDriveBackupStatus::Broken => { // unit let mut s = serializer.serialize_struct("ExternalDriveBackupStatus", 1)?; @@ -38311,7 +38311,7 @@ impl ::serde::ser::Serialize for FedAdminRole { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FedAdminRole::EnterpriseAdmin => { // unit let mut s = serializer.serialize_struct("FedAdminRole", 1)?; @@ -38377,15 +38377,15 @@ impl ::serde::ser::Serialize for FedExtraDetails { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - FedExtraDetails::Organization(ref x) => { + match self { + FedExtraDetails::Organization(x) => { // struct let mut s = serializer.serialize_struct("FedExtraDetails", 2)?; s.serialize_field(".tag", "organization")?; x.internal_serialize::(&mut s)?; s.end() } - FedExtraDetails::Team(ref x) => { + FedExtraDetails::Team(x) => { // struct let mut s = serializer.serialize_struct("FedExtraDetails", 2)?; s.serialize_field(".tag", "team")?; @@ -38454,7 +38454,7 @@ impl ::serde::ser::Serialize for FedHandshakeAction { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FedHandshakeAction::AcceptedInvite => { // unit let mut s = serializer.serialize_struct("FedHandshakeAction", 1)?; @@ -38548,22 +38548,22 @@ impl ::serde::ser::Serialize for FederationStatusChangeAdditionalInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - FederationStatusChangeAdditionalInfo::ConnectedTeamName(ref x) => { + match self { + FederationStatusChangeAdditionalInfo::ConnectedTeamName(x) => { // struct let mut s = serializer.serialize_struct("FederationStatusChangeAdditionalInfo", 2)?; s.serialize_field(".tag", "connected_team_name")?; x.internal_serialize::(&mut s)?; s.end() } - FederationStatusChangeAdditionalInfo::NonTrustedTeamDetails(ref x) => { + FederationStatusChangeAdditionalInfo::NonTrustedTeamDetails(x) => { // struct let mut s = serializer.serialize_struct("FederationStatusChangeAdditionalInfo", 2)?; s.serialize_field(".tag", "non_trusted_team_details")?; x.internal_serialize::(&mut s)?; s.end() } - FederationStatusChangeAdditionalInfo::OrganizationName(ref x) => { + FederationStatusChangeAdditionalInfo::OrganizationName(x) => { // struct let mut s = serializer.serialize_struct("FederationStatusChangeAdditionalInfo", 2)?; s.serialize_field(".tag", "organization_name")?; @@ -39263,7 +39263,7 @@ impl ::serde::ser::Serialize for FileCommentNotificationPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileCommentNotificationPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("FileCommentNotificationPolicy", 1)?; @@ -39529,7 +39529,7 @@ impl ::serde::ser::Serialize for FileCommentsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileCommentsPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("FileCommentsPolicy", 1)?; @@ -44150,7 +44150,7 @@ impl ::serde::ser::Serialize for FileRequestsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileRequestsPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("FileRequestsPolicy", 1)?; @@ -45152,7 +45152,7 @@ impl ::serde::ser::Serialize for FileTransfersPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileTransfersPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("FileTransfersPolicy", 1)?; @@ -46483,7 +46483,7 @@ impl ::serde::ser::Serialize for FolderLinkRestrictionPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FolderLinkRestrictionPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("FolderLinkRestrictionPolicy", 1)?; @@ -47932,14 +47932,14 @@ impl ::serde::ser::Serialize for GetTeamEventsContinueError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GetTeamEventsContinueError::BadCursor => { // unit let mut s = serializer.serialize_struct("GetTeamEventsContinueError", 1)?; s.serialize_field(".tag", "bad_cursor")?; s.end() } - GetTeamEventsContinueError::Reset(ref x) => { + GetTeamEventsContinueError::Reset(x) => { // primitive let mut s = serializer.serialize_struct("GetTeamEventsContinueError", 2)?; s.serialize_field(".tag", "reset")?; @@ -48016,7 +48016,7 @@ impl ::serde::ser::Serialize for GetTeamEventsError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GetTeamEventsError::AccountIdNotFound => { // unit let mut s = serializer.serialize_struct("GetTeamEventsError", 1)?; @@ -48427,7 +48427,7 @@ impl ::serde::ser::Serialize for GoogleSsoPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GoogleSsoPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("GoogleSsoPolicy", 1)?; @@ -52794,7 +52794,7 @@ impl ::serde::ser::Serialize for GroupJoinPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupJoinPolicy::Open => { // unit let mut s = serializer.serialize_struct("GroupJoinPolicy", 1)?; @@ -54678,7 +54678,7 @@ impl ::serde::ser::Serialize for IdentifierType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { IdentifierType::Email => { // unit let mut s = serializer.serialize_struct("IdentifierType", 1)?; @@ -55106,7 +55106,7 @@ impl ::serde::ser::Serialize for IntegrationPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { IntegrationPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("IntegrationPolicy", 1)?; @@ -55383,7 +55383,7 @@ impl ::serde::ser::Serialize for InviteAcceptanceEmailPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { InviteAcceptanceEmailPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("InviteAcceptanceEmailPolicy", 1)?; @@ -55650,7 +55650,7 @@ impl ::serde::ser::Serialize for InviteMethod { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { InviteMethod::AutoApprove => { // unit let mut s = serializer.serialize_struct("InviteMethod", 1)?; @@ -55975,7 +55975,7 @@ impl ::serde::ser::Serialize for LabelType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LabelType::PersonalInformation => { // unit let mut s = serializer.serialize_struct("LabelType", 1)?; @@ -58679,29 +58679,29 @@ impl ::serde::ser::Serialize for LinkedDeviceLogInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - LinkedDeviceLogInfo::DesktopDeviceSession(ref x) => { + match self { + LinkedDeviceLogInfo::DesktopDeviceSession(x) => { // struct let mut s = serializer.serialize_struct("LinkedDeviceLogInfo", 10)?; s.serialize_field(".tag", "desktop_device_session")?; x.internal_serialize::(&mut s)?; s.end() } - LinkedDeviceLogInfo::LegacyDeviceSession(ref x) => { + LinkedDeviceLogInfo::LegacyDeviceSession(x) => { // struct let mut s = serializer.serialize_struct("LinkedDeviceLogInfo", 13)?; s.serialize_field(".tag", "legacy_device_session")?; x.internal_serialize::(&mut s)?; s.end() } - LinkedDeviceLogInfo::MobileDeviceSession(ref x) => { + LinkedDeviceLogInfo::MobileDeviceSession(x) => { // struct let mut s = serializer.serialize_struct("LinkedDeviceLogInfo", 10)?; s.serialize_field(".tag", "mobile_device_session")?; x.internal_serialize::(&mut s)?; s.end() } - LinkedDeviceLogInfo::WebDeviceSession(ref x) => { + LinkedDeviceLogInfo::WebDeviceSession(x) => { // struct let mut s = serializer.serialize_struct("LinkedDeviceLogInfo", 8)?; s.serialize_field(".tag", "web_device_session")?; @@ -58759,7 +58759,7 @@ impl ::serde::ser::Serialize for LockStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LockStatus::Locked => { // unit let mut s = serializer.serialize_struct("LockStatus", 1)?; @@ -59058,7 +59058,7 @@ impl ::serde::ser::Serialize for LoginMethod { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { LoginMethod::AppleOauth => { // unit let mut s = serializer.serialize_struct("LoginMethod", 1)?; @@ -61758,7 +61758,7 @@ impl ::serde::ser::Serialize for MemberRemoveActionType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberRemoveActionType::Delete => { // unit let mut s = serializer.serialize_struct("MemberRemoveActionType", 1)?; @@ -62220,7 +62220,7 @@ impl ::serde::ser::Serialize for MemberRequestsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberRequestsPolicy::AutoAccept => { // unit let mut s = serializer.serialize_struct("MemberRequestsPolicy", 1)?; @@ -62293,7 +62293,7 @@ impl ::serde::ser::Serialize for MemberSendInvitePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberSendInvitePolicy::Disabled => { // unit let mut s = serializer.serialize_struct("MemberSendInvitePolicy", 1)?; @@ -64063,7 +64063,7 @@ impl ::serde::ser::Serialize for MemberStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberStatus::Active => { // unit let mut s = serializer.serialize_struct("MemberStatus", 1)?; @@ -64535,7 +64535,7 @@ impl ::serde::ser::Serialize for MemberSuggestionsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MemberSuggestionsPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("MemberSuggestionsPolicy", 1)?; @@ -65043,7 +65043,7 @@ impl ::serde::ser::Serialize for MicrosoftOfficeAddinPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { MicrosoftOfficeAddinPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("MicrosoftOfficeAddinPolicy", 1)?; @@ -65854,7 +65854,7 @@ impl ::serde::ser::Serialize for NetworkControlPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { NetworkControlPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("NetworkControlPolicy", 1)?; @@ -69438,7 +69438,7 @@ impl ::serde::ser::Serialize for PaperAccessType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperAccessType::Commenter => { // unit let mut s = serializer.serialize_struct("PaperAccessType", 1)?; @@ -72141,7 +72141,7 @@ impl ::serde::ser::Serialize for PaperDefaultFolderPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDefaultFolderPolicy::EveryoneInTeam => { // unit let mut s = serializer.serialize_struct("PaperDefaultFolderPolicy", 1)?; @@ -72403,7 +72403,7 @@ impl ::serde::ser::Serialize for PaperDesktopPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDesktopPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("PaperDesktopPolicy", 1)?; @@ -76829,7 +76829,7 @@ impl ::serde::ser::Serialize for PaperDownloadFormat { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDownloadFormat::Docx => { // unit let mut s = serializer.serialize_struct("PaperDownloadFormat", 1)?; @@ -78588,7 +78588,7 @@ impl ::serde::ser::Serialize for PaperMemberPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperMemberPolicy::AnyoneWithLink => { // unit let mut s = serializer.serialize_struct("PaperMemberPolicy", 1)?; @@ -79424,15 +79424,15 @@ impl ::serde::ser::Serialize for ParticipantLogInfo { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - ParticipantLogInfo::Group(ref x) => { + match self { + ParticipantLogInfo::Group(x) => { // struct let mut s = serializer.serialize_struct("ParticipantLogInfo", 4)?; s.serialize_field(".tag", "group")?; x.internal_serialize::(&mut s)?; s.end() } - ParticipantLogInfo::User(ref x) => { + ParticipantLogInfo::User(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("ParticipantLogInfo", 2)?; s.serialize_field(".tag", "user")?; @@ -79492,7 +79492,7 @@ impl ::serde::ser::Serialize for PassPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PassPolicy::Allow => { // unit let mut s = serializer.serialize_struct("PassPolicy", 1)?; @@ -80669,7 +80669,7 @@ impl ::serde::ser::Serialize for PlacementRestriction { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PlacementRestriction::AustraliaOnly => { // unit let mut s = serializer.serialize_struct("PlacementRestriction", 1)?; @@ -80756,7 +80756,7 @@ impl ::serde::ser::Serialize for PolicyType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PolicyType::Disposition => { // unit let mut s = serializer.serialize_struct("PolicyType", 1)?; @@ -81252,7 +81252,7 @@ impl ::serde::ser::Serialize for QuickActionType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { QuickActionType::DeleteSharedLink => { // unit let mut s = serializer.serialize_struct("QuickActionType", 1)?; @@ -83049,7 +83049,7 @@ impl ::serde::ser::Serialize for ResellerRole { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ResellerRole::NotReseller => { // unit let mut s = serializer.serialize_struct("ResellerRole", 1)?; @@ -83308,7 +83308,7 @@ impl ::serde::ser::Serialize for ResellerSupportPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ResellerSupportPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("ResellerSupportPolicy", 1)?; @@ -83822,7 +83822,7 @@ impl ::serde::ser::Serialize for RewindPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RewindPolicy::AdminsOnly => { // unit let mut s = serializer.serialize_struct("RewindPolicy", 1)?; @@ -84444,7 +84444,7 @@ impl ::serde::ser::Serialize for SecondaryMailsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SecondaryMailsPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("SecondaryMailsPolicy", 1)?; @@ -85097,7 +85097,7 @@ impl ::serde::ser::Serialize for SendForSignaturePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SendForSignaturePolicy::Disabled => { // unit let mut s = serializer.serialize_struct("SendForSignaturePolicy", 1)?; @@ -85359,20 +85359,20 @@ impl ::serde::ser::Serialize for SessionLogInfo { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - SessionLogInfo::Web(ref x) => { + match self { + SessionLogInfo::Web(x) => { let mut s = serializer.serialize_struct("SessionLogInfo", 2)?; s.serialize_field(".tag", "web")?; x.internal_serialize::(&mut s)?; s.end() } - SessionLogInfo::Desktop(ref x) => { + SessionLogInfo::Desktop(x) => { let mut s = serializer.serialize_struct("SessionLogInfo", 2)?; s.serialize_field(".tag", "desktop")?; x.internal_serialize::(&mut s)?; s.end() } - SessionLogInfo::Mobile(ref x) => { + SessionLogInfo::Mobile(x) => { let mut s = serializer.serialize_struct("SessionLogInfo", 2)?; s.serialize_field(".tag", "mobile")?; x.internal_serialize::(&mut s)?; @@ -93684,7 +93684,7 @@ impl ::serde::ser::Serialize for SharedFolderMembersInheritancePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedFolderMembersInheritancePolicy::DontInheritMembers => { // unit let mut s = serializer.serialize_struct("SharedFolderMembersInheritancePolicy", 1)?; @@ -94450,7 +94450,7 @@ impl ::serde::ser::Serialize for SharedLinkAccessLevel { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedLinkAccessLevel::None => { // unit let mut s = serializer.serialize_struct("SharedLinkAccessLevel", 1)?; @@ -98258,7 +98258,7 @@ impl ::serde::ser::Serialize for SharedLinkVisibility { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedLinkVisibility::NoOne => { // unit let mut s = serializer.serialize_struct("SharedLinkVisibility", 1)?; @@ -99681,7 +99681,7 @@ impl ::serde::ser::Serialize for SharingFolderJoinPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharingFolderJoinPolicy::FromAnyone => { // unit let mut s = serializer.serialize_struct("SharingFolderJoinPolicy", 1)?; @@ -99751,7 +99751,7 @@ impl ::serde::ser::Serialize for SharingLinkPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharingLinkPolicy::DefaultNoOne => { // unit let mut s = serializer.serialize_struct("SharingLinkPolicy", 1)?; @@ -99830,7 +99830,7 @@ impl ::serde::ser::Serialize for SharingMemberPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharingMemberPolicy::Allow => { // unit let mut s = serializer.serialize_struct("SharingMemberPolicy", 1)?; @@ -102001,7 +102001,7 @@ impl ::serde::ser::Serialize for ShowcaseDownloadPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShowcaseDownloadPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("ShowcaseDownloadPolicy", 1)?; @@ -102449,7 +102449,7 @@ impl ::serde::ser::Serialize for ShowcaseEnabledPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShowcaseEnabledPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("ShowcaseEnabledPolicy", 1)?; @@ -102513,7 +102513,7 @@ impl ::serde::ser::Serialize for ShowcaseExternalSharingPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShowcaseExternalSharingPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("ShowcaseExternalSharingPolicy", 1)?; @@ -106639,7 +106639,7 @@ impl ::serde::ser::Serialize for SmartSyncOptOutPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SmartSyncOptOutPolicy::Default => { // unit let mut s = serializer.serialize_struct("SmartSyncOptOutPolicy", 1)?; @@ -106994,7 +106994,7 @@ impl ::serde::ser::Serialize for SpaceCapsType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SpaceCapsType::Hard => { // unit let mut s = serializer.serialize_struct("SpaceCapsType", 1)?; @@ -107066,7 +107066,7 @@ impl ::serde::ser::Serialize for SpaceLimitsStatus { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SpaceLimitsStatus::NearQuota => { // unit let mut s = serializer.serialize_struct("SpaceLimitsStatus", 1)?; @@ -109899,7 +109899,7 @@ impl ::serde::ser::Serialize for TeamBrandingPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamBrandingPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("TeamBrandingPolicy", 1)?; @@ -111452,7 +111452,7 @@ impl ::serde::ser::Serialize for TeamExtensionsPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamExtensionsPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("TeamExtensionsPolicy", 1)?; @@ -113057,7 +113057,7 @@ impl ::serde::ser::Serialize for TeamMembershipType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamMembershipType::Free => { // unit let mut s = serializer.serialize_struct("TeamMembershipType", 1)?; @@ -113403,15 +113403,15 @@ impl ::serde::ser::Serialize for TeamMergeRequestAcceptedExtraDetails { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamMergeRequestAcceptedExtraDetails::PrimaryTeam(ref x) => { + match self { + TeamMergeRequestAcceptedExtraDetails::PrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("TeamMergeRequestAcceptedExtraDetails", 3)?; s.serialize_field(".tag", "primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - TeamMergeRequestAcceptedExtraDetails::SecondaryTeam(ref x) => { + TeamMergeRequestAcceptedExtraDetails::SecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("TeamMergeRequestAcceptedExtraDetails", 3)?; s.serialize_field(".tag", "secondary_team")?; @@ -114215,15 +114215,15 @@ impl ::serde::ser::Serialize for TeamMergeRequestCanceledExtraDetails { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamMergeRequestCanceledExtraDetails::PrimaryTeam(ref x) => { + match self { + TeamMergeRequestCanceledExtraDetails::PrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("TeamMergeRequestCanceledExtraDetails", 3)?; s.serialize_field(".tag", "primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - TeamMergeRequestCanceledExtraDetails::SecondaryTeam(ref x) => { + TeamMergeRequestCanceledExtraDetails::SecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("TeamMergeRequestCanceledExtraDetails", 3)?; s.serialize_field(".tag", "secondary_team")?; @@ -114855,15 +114855,15 @@ impl ::serde::ser::Serialize for TeamMergeRequestExpiredExtraDetails { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamMergeRequestExpiredExtraDetails::PrimaryTeam(ref x) => { + match self { + TeamMergeRequestExpiredExtraDetails::PrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("TeamMergeRequestExpiredExtraDetails", 3)?; s.serialize_field(".tag", "primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - TeamMergeRequestExpiredExtraDetails::SecondaryTeam(ref x) => { + TeamMergeRequestExpiredExtraDetails::SecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("TeamMergeRequestExpiredExtraDetails", 2)?; s.serialize_field(".tag", "secondary_team")?; @@ -115859,15 +115859,15 @@ impl ::serde::ser::Serialize for TeamMergeRequestReminderExtraDetails { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - TeamMergeRequestReminderExtraDetails::PrimaryTeam(ref x) => { + match self { + TeamMergeRequestReminderExtraDetails::PrimaryTeam(x) => { // struct let mut s = serializer.serialize_struct("TeamMergeRequestReminderExtraDetails", 3)?; s.serialize_field(".tag", "primary_team")?; x.internal_serialize::(&mut s)?; s.end() } - TeamMergeRequestReminderExtraDetails::SecondaryTeam(ref x) => { + TeamMergeRequestReminderExtraDetails::SecondaryTeam(x) => { // struct let mut s = serializer.serialize_struct("TeamMergeRequestReminderExtraDetails", 2)?; s.serialize_field(".tag", "secondary_team")?; @@ -118442,7 +118442,7 @@ impl ::serde::ser::Serialize for TeamSelectiveSyncPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TeamSelectiveSyncPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("TeamSelectiveSyncPolicy", 1)?; @@ -120071,7 +120071,7 @@ impl ::serde::ser::Serialize for TfaConfiguration { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TfaConfiguration::Authenticator => { // unit let mut s = serializer.serialize_struct("TfaConfiguration", 1)?; @@ -120700,7 +120700,7 @@ impl ::serde::ser::Serialize for TimeUnit { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TimeUnit::Days => { // unit let mut s = serializer.serialize_struct("TimeUnit", 1)?; @@ -120977,7 +120977,7 @@ impl ::serde::ser::Serialize for TrustedNonTeamMemberType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TrustedNonTeamMemberType::EnterpriseAdmin => { // unit let mut s = serializer.serialize_struct("TrustedNonTeamMemberType", 1)?; @@ -121049,7 +121049,7 @@ impl ::serde::ser::Serialize for TrustedTeamsRequestAction { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TrustedTeamsRequestAction::Accepted => { // unit let mut s = serializer.serialize_struct("TrustedTeamsRequestAction", 1)?; @@ -121133,7 +121133,7 @@ impl ::serde::ser::Serialize for TrustedTeamsRequestState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TrustedTeamsRequestState::Invited => { // unit let mut s = serializer.serialize_struct("TrustedTeamsRequestState", 1)?; @@ -121406,7 +121406,7 @@ impl ::serde::ser::Serialize for TwoAccountPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TwoAccountPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("TwoAccountPolicy", 1)?; @@ -121848,20 +121848,20 @@ impl ::serde::ser::Serialize for UserLogInfo { fn serialize(&self, serializer: S) -> Result { // polymorphic struct serializer use serde::ser::SerializeStruct; - match *self { - UserLogInfo::TeamMember(ref x) => { + match self { + UserLogInfo::TeamMember(x) => { let mut s = serializer.serialize_struct("UserLogInfo", 7)?; s.serialize_field(".tag", "team_member")?; x.internal_serialize::(&mut s)?; s.end() } - UserLogInfo::TrustedNonTeamMember(ref x) => { + UserLogInfo::TrustedNonTeamMember(x) => { let mut s = serializer.serialize_struct("UserLogInfo", 6)?; s.serialize_field(".tag", "trusted_non_team_member")?; x.internal_serialize::(&mut s)?; s.end() } - UserLogInfo::NonTeamMember(ref x) => { + UserLogInfo::NonTeamMember(x) => { let mut s = serializer.serialize_struct("UserLogInfo", 4)?; s.serialize_field(".tag", "non_team_member")?; x.internal_serialize::(&mut s)?; @@ -122709,7 +122709,7 @@ impl ::serde::ser::Serialize for WatermarkingPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { WatermarkingPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("WatermarkingPolicy", 1)?; @@ -123839,8 +123839,8 @@ impl ::serde::ser::Serialize for WebSessionsFixedLengthPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - WebSessionsFixedLengthPolicy::Defined(ref x) => { + match self { + WebSessionsFixedLengthPolicy::Defined(x) => { // struct let mut s = serializer.serialize_struct("WebSessionsFixedLengthPolicy", 3)?; s.serialize_field(".tag", "defined")?; @@ -123906,8 +123906,8 @@ impl ::serde::ser::Serialize for WebSessionsIdleLengthPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - WebSessionsIdleLengthPolicy::Defined(ref x) => { + match self { + WebSessionsIdleLengthPolicy::Defined(x) => { // struct let mut s = serializer.serialize_struct("WebSessionsIdleLengthPolicy", 3)?; s.serialize_field(".tag", "defined")?; diff --git a/src/generated/types/team_policies.rs b/src/generated/types/team_policies.rs index bcc8827..a1e6d52 100644 --- a/src/generated/types/team_policies.rs +++ b/src/generated/types/team_policies.rs @@ -55,7 +55,7 @@ impl ::serde::ser::Serialize for CameraUploadsPolicyState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { CameraUploadsPolicyState::Disabled => { // unit let mut s = serializer.serialize_struct("CameraUploadsPolicyState", 1)?; @@ -124,7 +124,7 @@ impl ::serde::ser::Serialize for ComputerBackupPolicyState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ComputerBackupPolicyState::Disabled => { // unit let mut s = serializer.serialize_struct("ComputerBackupPolicyState", 1)?; @@ -199,7 +199,7 @@ impl ::serde::ser::Serialize for EmmState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { EmmState::Disabled => { // unit let mut s = serializer.serialize_struct("EmmState", 1)?; @@ -274,7 +274,7 @@ impl ::serde::ser::Serialize for ExternalDriveBackupPolicyState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ExternalDriveBackupPolicyState::Disabled => { // unit let mut s = serializer.serialize_struct("ExternalDriveBackupPolicyState", 1)?; @@ -345,7 +345,7 @@ impl ::serde::ser::Serialize for FileLockingPolicyState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileLockingPolicyState::Disabled => { // unit let mut s = serializer.serialize_struct("FileLockingPolicyState", 1)?; @@ -414,7 +414,7 @@ impl ::serde::ser::Serialize for FileProviderMigrationPolicyState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { FileProviderMigrationPolicyState::Disabled => { // unit let mut s = serializer.serialize_struct("FileProviderMigrationPolicyState", 1)?; @@ -480,7 +480,7 @@ impl ::serde::ser::Serialize for GroupCreation { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GroupCreation::AdminsAndMembers => { // unit let mut s = serializer.serialize_struct("GroupCreation", 1)?; @@ -544,7 +544,7 @@ impl ::serde::ser::Serialize for OfficeAddInPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { OfficeAddInPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("OfficeAddInPolicy", 1)?; @@ -609,7 +609,7 @@ impl ::serde::ser::Serialize for PaperDefaultFolderPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDefaultFolderPolicy::EveryoneInTeam => { // unit let mut s = serializer.serialize_struct("PaperDefaultFolderPolicy", 1)?; @@ -675,7 +675,7 @@ impl ::serde::ser::Serialize for PaperDeploymentPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDeploymentPolicy::Full => { // unit let mut s = serializer.serialize_struct("PaperDeploymentPolicy", 1)?; @@ -740,7 +740,7 @@ impl ::serde::ser::Serialize for PaperDesktopPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperDesktopPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("PaperDesktopPolicy", 1)?; @@ -809,7 +809,7 @@ impl ::serde::ser::Serialize for PaperEnabledPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PaperEnabledPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("PaperEnabledPolicy", 1)?; @@ -880,7 +880,7 @@ impl ::serde::ser::Serialize for PasswordControlMode { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PasswordControlMode::Disabled => { // unit let mut s = serializer.serialize_struct("PasswordControlMode", 1)?; @@ -949,7 +949,7 @@ impl ::serde::ser::Serialize for PasswordStrengthPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { PasswordStrengthPolicy::MinimalRequirements => { // unit let mut s = serializer.serialize_struct("PasswordStrengthPolicy", 1)?; @@ -1019,7 +1019,7 @@ impl ::serde::ser::Serialize for RolloutMethod { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { RolloutMethod::UnlinkAll => { // unit let mut s = serializer.serialize_struct("RolloutMethod", 1)?; @@ -1090,7 +1090,7 @@ impl ::serde::ser::Serialize for SharedFolderBlanketLinkRestrictionPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedFolderBlanketLinkRestrictionPolicy::Members => { // unit let mut s = serializer.serialize_struct("SharedFolderBlanketLinkRestrictionPolicy", 1)?; @@ -1156,7 +1156,7 @@ impl ::serde::ser::Serialize for SharedFolderJoinPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedFolderJoinPolicy::FromTeamOnly => { // unit let mut s = serializer.serialize_struct("SharedFolderJoinPolicy", 1)?; @@ -1222,7 +1222,7 @@ impl ::serde::ser::Serialize for SharedFolderMemberPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedFolderMemberPolicy::Team => { // unit let mut s = serializer.serialize_struct("SharedFolderMemberPolicy", 1)?; @@ -1301,7 +1301,7 @@ impl ::serde::ser::Serialize for SharedLinkCreatePolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SharedLinkCreatePolicy::DefaultPublic => { // unit let mut s = serializer.serialize_struct("SharedLinkCreatePolicy", 1)?; @@ -1378,7 +1378,7 @@ impl ::serde::ser::Serialize for ShowcaseDownloadPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShowcaseDownloadPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("ShowcaseDownloadPolicy", 1)?; @@ -1443,7 +1443,7 @@ impl ::serde::ser::Serialize for ShowcaseEnabledPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShowcaseEnabledPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("ShowcaseEnabledPolicy", 1)?; @@ -1508,7 +1508,7 @@ impl ::serde::ser::Serialize for ShowcaseExternalSharingPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { ShowcaseExternalSharingPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("ShowcaseExternalSharingPolicy", 1)?; @@ -1573,7 +1573,7 @@ impl ::serde::ser::Serialize for SmartSyncPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SmartSyncPolicy::Local => { // unit let mut s = serializer.serialize_struct("SmartSyncPolicy", 1)?; @@ -1638,7 +1638,7 @@ impl ::serde::ser::Serialize for SmarterSmartSyncPolicyState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SmarterSmartSyncPolicyState::Disabled => { // unit let mut s = serializer.serialize_struct("SmarterSmartSyncPolicyState", 1)?; @@ -1707,7 +1707,7 @@ impl ::serde::ser::Serialize for SsoPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SsoPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("SsoPolicy", 1)?; @@ -1778,7 +1778,7 @@ impl ::serde::ser::Serialize for SuggestMembersPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { SuggestMembersPolicy::Disabled => { // unit let mut s = serializer.serialize_struct("SuggestMembersPolicy", 1)?; @@ -2134,7 +2134,7 @@ impl ::serde::ser::Serialize for TwoStepVerificationPolicy { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TwoStepVerificationPolicy::RequireTfaEnable => { // unit let mut s = serializer.serialize_struct("TwoStepVerificationPolicy", 1)?; @@ -2203,7 +2203,7 @@ impl ::serde::ser::Serialize for TwoStepVerificationState { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { TwoStepVerificationState::Required => { // unit let mut s = serializer.serialize_struct("TwoStepVerificationState", 1)?; diff --git a/src/generated/types/users.rs b/src/generated/types/users.rs index 1d18515..0a53705 100644 --- a/src/generated/types/users.rs +++ b/src/generated/types/users.rs @@ -456,8 +456,8 @@ impl ::serde::ser::Serialize for FileLockingValue { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - FileLockingValue::Enabled(ref x) => { + match self { + FileLockingValue::Enabled(x) => { // primitive let mut s = serializer.serialize_struct("FileLockingValue", 2)?; s.serialize_field(".tag", "enabled")?; @@ -1163,8 +1163,8 @@ impl ::serde::ser::Serialize for GetAccountBatchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - GetAccountBatchError::NoAccount(ref x) => { + match self { + GetAccountBatchError::NoAccount(x) => { // primitive let mut s = serializer.serialize_struct("GetAccountBatchError", 2)?; s.serialize_field(".tag", "no_account")?; @@ -1231,7 +1231,7 @@ impl ::serde::ser::Serialize for GetAccountError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { GetAccountError::NoAccount => { // unit let mut s = serializer.serialize_struct("GetAccountError", 1)?; @@ -1547,8 +1547,8 @@ impl ::serde::ser::Serialize for PaperAsFilesValue { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - PaperAsFilesValue::Enabled(ref x) => { + match self { + PaperAsFilesValue::Enabled(x) => { // primitive let mut s = serializer.serialize_struct("PaperAsFilesValue", 2)?; s.serialize_field(".tag", "enabled")?; @@ -1608,15 +1608,15 @@ impl ::serde::ser::Serialize for SpaceAllocation { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - SpaceAllocation::Individual(ref x) => { + match self { + SpaceAllocation::Individual(x) => { // struct let mut s = serializer.serialize_struct("SpaceAllocation", 2)?; s.serialize_field(".tag", "individual")?; x.internal_serialize::(&mut s)?; s.end() } - SpaceAllocation::Team(ref x) => { + SpaceAllocation::Team(x) => { // struct let mut s = serializer.serialize_struct("SpaceAllocation", 6)?; s.serialize_field(".tag", "team")?; @@ -2036,7 +2036,7 @@ impl ::serde::ser::Serialize for UserFeature { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UserFeature::PaperAsFiles => { // unit let mut s = serializer.serialize_struct("UserFeature", 1)?; @@ -2112,15 +2112,15 @@ impl ::serde::ser::Serialize for UserFeatureValue { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { - UserFeatureValue::PaperAsFiles(ref x) => { + match self { + UserFeatureValue::PaperAsFiles(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UserFeatureValue", 2)?; s.serialize_field(".tag", "paper_as_files")?; s.serialize_field("paper_as_files", x)?; s.end() } - UserFeatureValue::FileLocking(ref x) => { + UserFeatureValue::FileLocking(x) => { // union or polymporphic struct let mut s = serializer.serialize_struct("UserFeatureValue", 2)?; s.serialize_field(".tag", "file_locking")?; @@ -2268,7 +2268,7 @@ impl ::serde::ser::Serialize for UserFeaturesGetValuesBatchError { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { UserFeaturesGetValuesBatchError::EmptyFeaturesList => { // unit let mut s = serializer.serialize_struct("UserFeaturesGetValuesBatchError", 1)?; diff --git a/src/generated/types/users_common.rs b/src/generated/types/users_common.rs index 6395d17..6672c10 100644 --- a/src/generated/types/users_common.rs +++ b/src/generated/types/users_common.rs @@ -59,7 +59,7 @@ impl ::serde::ser::Serialize for AccountType { fn serialize(&self, serializer: S) -> Result { // union serializer use serde::ser::SerializeStruct; - match *self { + match self { AccountType::Basic => { // unit let mut s = serializer.serialize_struct("AccountType", 1)?;