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)?;