1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct SportsEvent {
6 pub r#away_team: Vec<AwayTeamProperty>,
8 pub r#competitor: Vec<CompetitorProperty>,
10 pub r#home_team: Vec<HomeTeamProperty>,
12 pub r#sport: Vec<SportProperty>,
14 pub r#about: Vec<AboutProperty>,
16 pub r#actor: Vec<ActorProperty>,
18 pub r#aggregate_rating: Vec<AggregateRatingProperty>,
20 pub r#attendee: Vec<AttendeeProperty>,
22 #[deprecated = "This schema is superseded by <https://schema.org/attendee>."]
24 pub r#attendees: Vec<AttendeesProperty>,
25 pub r#audience: Vec<AudienceProperty>,
27 pub r#composer: Vec<ComposerProperty>,
29 pub r#contributor: Vec<ContributorProperty>,
31 pub r#director: Vec<DirectorProperty>,
33 pub r#door_time: Vec<DoorTimeProperty>,
35 pub r#duration: Vec<DurationProperty>,
37 pub r#end_date: Vec<EndDateProperty>,
39 pub r#event_attendance_mode: Vec<EventAttendanceModeProperty>,
41 pub r#event_schedule: Vec<EventScheduleProperty>,
43 pub r#event_status: Vec<EventStatusProperty>,
45 pub r#funder: Vec<FunderProperty>,
47 pub r#funding: Vec<FundingProperty>,
49 pub r#in_language: Vec<InLanguageProperty>,
51 pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
53 pub r#keywords: Vec<KeywordsProperty>,
55 pub r#location: Vec<LocationProperty>,
57 pub r#maximum_attendee_capacity: Vec<MaximumAttendeeCapacityProperty>,
59 pub r#maximum_physical_attendee_capacity: Vec<MaximumPhysicalAttendeeCapacityProperty>,
61 pub r#maximum_virtual_attendee_capacity: Vec<MaximumVirtualAttendeeCapacityProperty>,
63 pub r#offers: Vec<OffersProperty>,
65 pub r#organizer: Vec<OrganizerProperty>,
67 pub r#performer: Vec<PerformerProperty>,
69 #[deprecated = "This schema is superseded by <https://schema.org/performer>."]
71 pub r#performers: Vec<PerformersProperty>,
72 pub r#previous_start_date: Vec<PreviousStartDateProperty>,
74 pub r#recorded_in: Vec<RecordedInProperty>,
76 pub r#remaining_attendee_capacity: Vec<RemainingAttendeeCapacityProperty>,
78 pub r#review: Vec<ReviewProperty>,
80 pub r#sponsor: Vec<SponsorProperty>,
82 pub r#start_date: Vec<StartDateProperty>,
84 pub r#sub_event: Vec<SubEventProperty>,
86 #[deprecated = "This schema is superseded by <https://schema.org/subEvent>."]
88 pub r#sub_events: Vec<SubEventsProperty>,
89 pub r#super_event: Vec<SuperEventProperty>,
91 pub r#translator: Vec<TranslatorProperty>,
93 pub r#typical_age_range: Vec<TypicalAgeRangeProperty>,
95 pub r#work_featured: Vec<WorkFeaturedProperty>,
97 pub r#work_performed: Vec<WorkPerformedProperty>,
99 pub r#additional_type: Vec<AdditionalTypeProperty>,
101 pub r#alternate_name: Vec<AlternateNameProperty>,
103 pub r#description: Vec<DescriptionProperty>,
105 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
107 pub r#identifier: Vec<IdentifierProperty>,
109 pub r#image: Vec<ImageProperty>,
111 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
113 pub r#name: Vec<NameProperty>,
115 pub r#potential_action: Vec<PotentialActionProperty>,
117 pub r#same_as: Vec<SameAsProperty>,
119 pub r#subject_of: Vec<SubjectOfProperty>,
121 pub r#url: Vec<UrlProperty>,
123}
124pub trait SportsEventTrait {
126 fn get_away_team(&self) -> &[AwayTeamProperty];
128 fn take_away_team(&mut self) -> Vec<AwayTeamProperty>;
130 fn get_competitor(&self) -> &[CompetitorProperty];
132 fn take_competitor(&mut self) -> Vec<CompetitorProperty>;
134 fn get_home_team(&self) -> &[HomeTeamProperty];
136 fn take_home_team(&mut self) -> Vec<HomeTeamProperty>;
138 fn get_sport(&self) -> &[SportProperty];
140 fn take_sport(&mut self) -> Vec<SportProperty>;
142}
143impl SportsEventTrait for SportsEvent {
144 fn get_away_team(&self) -> &[AwayTeamProperty] {
145 self.r#away_team.as_slice()
146 }
147 fn take_away_team(&mut self) -> Vec<AwayTeamProperty> {
148 std::mem::take(&mut self.r#away_team)
149 }
150 fn get_competitor(&self) -> &[CompetitorProperty] {
151 self.r#competitor.as_slice()
152 }
153 fn take_competitor(&mut self) -> Vec<CompetitorProperty> {
154 std::mem::take(&mut self.r#competitor)
155 }
156 fn get_home_team(&self) -> &[HomeTeamProperty] {
157 self.r#home_team.as_slice()
158 }
159 fn take_home_team(&mut self) -> Vec<HomeTeamProperty> {
160 std::mem::take(&mut self.r#home_team)
161 }
162 fn get_sport(&self) -> &[SportProperty] {
163 self.r#sport.as_slice()
164 }
165 fn take_sport(&mut self) -> Vec<SportProperty> {
166 std::mem::take(&mut self.r#sport)
167 }
168}
169impl EventTrait for SportsEvent {
170 fn get_about(&self) -> &[AboutProperty] {
171 self.r#about.as_slice()
172 }
173 fn take_about(&mut self) -> Vec<AboutProperty> {
174 std::mem::take(&mut self.r#about)
175 }
176 fn get_actor(&self) -> &[ActorProperty] {
177 self.r#actor.as_slice()
178 }
179 fn take_actor(&mut self) -> Vec<ActorProperty> {
180 std::mem::take(&mut self.r#actor)
181 }
182 fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
183 self.r#aggregate_rating.as_slice()
184 }
185 fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
186 std::mem::take(&mut self.r#aggregate_rating)
187 }
188 fn get_attendee(&self) -> &[AttendeeProperty] {
189 self.r#attendee.as_slice()
190 }
191 fn take_attendee(&mut self) -> Vec<AttendeeProperty> {
192 std::mem::take(&mut self.r#attendee)
193 }
194 fn get_attendees(&self) -> &[AttendeesProperty] {
195 self.r#attendees.as_slice()
196 }
197 fn take_attendees(&mut self) -> Vec<AttendeesProperty> {
198 std::mem::take(&mut self.r#attendees)
199 }
200 fn get_audience(&self) -> &[AudienceProperty] {
201 self.r#audience.as_slice()
202 }
203 fn take_audience(&mut self) -> Vec<AudienceProperty> {
204 std::mem::take(&mut self.r#audience)
205 }
206 fn get_composer(&self) -> &[ComposerProperty] {
207 self.r#composer.as_slice()
208 }
209 fn take_composer(&mut self) -> Vec<ComposerProperty> {
210 std::mem::take(&mut self.r#composer)
211 }
212 fn get_contributor(&self) -> &[ContributorProperty] {
213 self.r#contributor.as_slice()
214 }
215 fn take_contributor(&mut self) -> Vec<ContributorProperty> {
216 std::mem::take(&mut self.r#contributor)
217 }
218 fn get_director(&self) -> &[DirectorProperty] {
219 self.r#director.as_slice()
220 }
221 fn take_director(&mut self) -> Vec<DirectorProperty> {
222 std::mem::take(&mut self.r#director)
223 }
224 fn get_door_time(&self) -> &[DoorTimeProperty] {
225 self.r#door_time.as_slice()
226 }
227 fn take_door_time(&mut self) -> Vec<DoorTimeProperty> {
228 std::mem::take(&mut self.r#door_time)
229 }
230 fn get_duration(&self) -> &[DurationProperty] {
231 self.r#duration.as_slice()
232 }
233 fn take_duration(&mut self) -> Vec<DurationProperty> {
234 std::mem::take(&mut self.r#duration)
235 }
236 fn get_end_date(&self) -> &[EndDateProperty] {
237 self.r#end_date.as_slice()
238 }
239 fn take_end_date(&mut self) -> Vec<EndDateProperty> {
240 std::mem::take(&mut self.r#end_date)
241 }
242 fn get_event_attendance_mode(&self) -> &[EventAttendanceModeProperty] {
243 self.r#event_attendance_mode.as_slice()
244 }
245 fn take_event_attendance_mode(&mut self) -> Vec<EventAttendanceModeProperty> {
246 std::mem::take(&mut self.r#event_attendance_mode)
247 }
248 fn get_event_schedule(&self) -> &[EventScheduleProperty] {
249 self.r#event_schedule.as_slice()
250 }
251 fn take_event_schedule(&mut self) -> Vec<EventScheduleProperty> {
252 std::mem::take(&mut self.r#event_schedule)
253 }
254 fn get_event_status(&self) -> &[EventStatusProperty] {
255 self.r#event_status.as_slice()
256 }
257 fn take_event_status(&mut self) -> Vec<EventStatusProperty> {
258 std::mem::take(&mut self.r#event_status)
259 }
260 fn get_funder(&self) -> &[FunderProperty] {
261 self.r#funder.as_slice()
262 }
263 fn take_funder(&mut self) -> Vec<FunderProperty> {
264 std::mem::take(&mut self.r#funder)
265 }
266 fn get_funding(&self) -> &[FundingProperty] {
267 self.r#funding.as_slice()
268 }
269 fn take_funding(&mut self) -> Vec<FundingProperty> {
270 std::mem::take(&mut self.r#funding)
271 }
272 fn get_in_language(&self) -> &[InLanguageProperty] {
273 self.r#in_language.as_slice()
274 }
275 fn take_in_language(&mut self) -> Vec<InLanguageProperty> {
276 std::mem::take(&mut self.r#in_language)
277 }
278 fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
279 self.r#is_accessible_for_free.as_slice()
280 }
281 fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
282 std::mem::take(&mut self.r#is_accessible_for_free)
283 }
284 fn get_keywords(&self) -> &[KeywordsProperty] {
285 self.r#keywords.as_slice()
286 }
287 fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
288 std::mem::take(&mut self.r#keywords)
289 }
290 fn get_location(&self) -> &[LocationProperty] {
291 self.r#location.as_slice()
292 }
293 fn take_location(&mut self) -> Vec<LocationProperty> {
294 std::mem::take(&mut self.r#location)
295 }
296 fn get_maximum_attendee_capacity(&self) -> &[MaximumAttendeeCapacityProperty] {
297 self.r#maximum_attendee_capacity.as_slice()
298 }
299 fn take_maximum_attendee_capacity(&mut self) -> Vec<MaximumAttendeeCapacityProperty> {
300 std::mem::take(&mut self.r#maximum_attendee_capacity)
301 }
302 fn get_maximum_physical_attendee_capacity(&self) -> &[MaximumPhysicalAttendeeCapacityProperty] {
303 self.r#maximum_physical_attendee_capacity.as_slice()
304 }
305 fn take_maximum_physical_attendee_capacity(
306 &mut self,
307 ) -> Vec<MaximumPhysicalAttendeeCapacityProperty> {
308 std::mem::take(&mut self.r#maximum_physical_attendee_capacity)
309 }
310 fn get_maximum_virtual_attendee_capacity(&self) -> &[MaximumVirtualAttendeeCapacityProperty] {
311 self.r#maximum_virtual_attendee_capacity.as_slice()
312 }
313 fn take_maximum_virtual_attendee_capacity(
314 &mut self,
315 ) -> Vec<MaximumVirtualAttendeeCapacityProperty> {
316 std::mem::take(&mut self.r#maximum_virtual_attendee_capacity)
317 }
318 fn get_offers(&self) -> &[OffersProperty] {
319 self.r#offers.as_slice()
320 }
321 fn take_offers(&mut self) -> Vec<OffersProperty> {
322 std::mem::take(&mut self.r#offers)
323 }
324 fn get_organizer(&self) -> &[OrganizerProperty] {
325 self.r#organizer.as_slice()
326 }
327 fn take_organizer(&mut self) -> Vec<OrganizerProperty> {
328 std::mem::take(&mut self.r#organizer)
329 }
330 fn get_performer(&self) -> &[PerformerProperty] {
331 self.r#performer.as_slice()
332 }
333 fn take_performer(&mut self) -> Vec<PerformerProperty> {
334 std::mem::take(&mut self.r#performer)
335 }
336 fn get_performers(&self) -> &[PerformersProperty] {
337 self.r#performers.as_slice()
338 }
339 fn take_performers(&mut self) -> Vec<PerformersProperty> {
340 std::mem::take(&mut self.r#performers)
341 }
342 fn get_previous_start_date(&self) -> &[PreviousStartDateProperty] {
343 self.r#previous_start_date.as_slice()
344 }
345 fn take_previous_start_date(&mut self) -> Vec<PreviousStartDateProperty> {
346 std::mem::take(&mut self.r#previous_start_date)
347 }
348 fn get_recorded_in(&self) -> &[RecordedInProperty] {
349 self.r#recorded_in.as_slice()
350 }
351 fn take_recorded_in(&mut self) -> Vec<RecordedInProperty> {
352 std::mem::take(&mut self.r#recorded_in)
353 }
354 fn get_remaining_attendee_capacity(&self) -> &[RemainingAttendeeCapacityProperty] {
355 self.r#remaining_attendee_capacity.as_slice()
356 }
357 fn take_remaining_attendee_capacity(&mut self) -> Vec<RemainingAttendeeCapacityProperty> {
358 std::mem::take(&mut self.r#remaining_attendee_capacity)
359 }
360 fn get_review(&self) -> &[ReviewProperty] {
361 self.r#review.as_slice()
362 }
363 fn take_review(&mut self) -> Vec<ReviewProperty> {
364 std::mem::take(&mut self.r#review)
365 }
366 fn get_sponsor(&self) -> &[SponsorProperty] {
367 self.r#sponsor.as_slice()
368 }
369 fn take_sponsor(&mut self) -> Vec<SponsorProperty> {
370 std::mem::take(&mut self.r#sponsor)
371 }
372 fn get_start_date(&self) -> &[StartDateProperty] {
373 self.r#start_date.as_slice()
374 }
375 fn take_start_date(&mut self) -> Vec<StartDateProperty> {
376 std::mem::take(&mut self.r#start_date)
377 }
378 fn get_sub_event(&self) -> &[SubEventProperty] {
379 self.r#sub_event.as_slice()
380 }
381 fn take_sub_event(&mut self) -> Vec<SubEventProperty> {
382 std::mem::take(&mut self.r#sub_event)
383 }
384 fn get_sub_events(&self) -> &[SubEventsProperty] {
385 self.r#sub_events.as_slice()
386 }
387 fn take_sub_events(&mut self) -> Vec<SubEventsProperty> {
388 std::mem::take(&mut self.r#sub_events)
389 }
390 fn get_super_event(&self) -> &[SuperEventProperty] {
391 self.r#super_event.as_slice()
392 }
393 fn take_super_event(&mut self) -> Vec<SuperEventProperty> {
394 std::mem::take(&mut self.r#super_event)
395 }
396 fn get_translator(&self) -> &[TranslatorProperty] {
397 self.r#translator.as_slice()
398 }
399 fn take_translator(&mut self) -> Vec<TranslatorProperty> {
400 std::mem::take(&mut self.r#translator)
401 }
402 fn get_typical_age_range(&self) -> &[TypicalAgeRangeProperty] {
403 self.r#typical_age_range.as_slice()
404 }
405 fn take_typical_age_range(&mut self) -> Vec<TypicalAgeRangeProperty> {
406 std::mem::take(&mut self.r#typical_age_range)
407 }
408 fn get_work_featured(&self) -> &[WorkFeaturedProperty] {
409 self.r#work_featured.as_slice()
410 }
411 fn take_work_featured(&mut self) -> Vec<WorkFeaturedProperty> {
412 std::mem::take(&mut self.r#work_featured)
413 }
414 fn get_work_performed(&self) -> &[WorkPerformedProperty] {
415 self.r#work_performed.as_slice()
416 }
417 fn take_work_performed(&mut self) -> Vec<WorkPerformedProperty> {
418 std::mem::take(&mut self.r#work_performed)
419 }
420}
421impl ThingTrait for SportsEvent {
422 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
423 self.r#additional_type.as_slice()
424 }
425 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
426 std::mem::take(&mut self.r#additional_type)
427 }
428 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
429 self.r#alternate_name.as_slice()
430 }
431 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
432 std::mem::take(&mut self.r#alternate_name)
433 }
434 fn get_description(&self) -> &[DescriptionProperty] {
435 self.r#description.as_slice()
436 }
437 fn take_description(&mut self) -> Vec<DescriptionProperty> {
438 std::mem::take(&mut self.r#description)
439 }
440 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
441 self.r#disambiguating_description.as_slice()
442 }
443 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
444 std::mem::take(&mut self.r#disambiguating_description)
445 }
446 fn get_identifier(&self) -> &[IdentifierProperty] {
447 self.r#identifier.as_slice()
448 }
449 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
450 std::mem::take(&mut self.r#identifier)
451 }
452 fn get_image(&self) -> &[ImageProperty] {
453 self.r#image.as_slice()
454 }
455 fn take_image(&mut self) -> Vec<ImageProperty> {
456 std::mem::take(&mut self.r#image)
457 }
458 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
459 self.r#main_entity_of_page.as_slice()
460 }
461 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
462 std::mem::take(&mut self.r#main_entity_of_page)
463 }
464 fn get_name(&self) -> &[NameProperty] {
465 self.r#name.as_slice()
466 }
467 fn take_name(&mut self) -> Vec<NameProperty> {
468 std::mem::take(&mut self.r#name)
469 }
470 fn get_potential_action(&self) -> &[PotentialActionProperty] {
471 self.r#potential_action.as_slice()
472 }
473 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
474 std::mem::take(&mut self.r#potential_action)
475 }
476 fn get_same_as(&self) -> &[SameAsProperty] {
477 self.r#same_as.as_slice()
478 }
479 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
480 std::mem::take(&mut self.r#same_as)
481 }
482 fn get_subject_of(&self) -> &[SubjectOfProperty] {
483 self.r#subject_of.as_slice()
484 }
485 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
486 std::mem::take(&mut self.r#subject_of)
487 }
488 fn get_url(&self) -> &[UrlProperty] {
489 self.r#url.as_slice()
490 }
491 fn take_url(&mut self) -> Vec<UrlProperty> {
492 std::mem::take(&mut self.r#url)
493 }
494}
495#[cfg(feature = "serde")]
496mod serde {
497 use std::{fmt, fmt::Formatter};
498
499 use ::serde::{
500 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
501 };
502
503 use super::*;
504 impl Serialize for SportsEvent {
505 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
506 where
507 S: Serializer,
508 {
509 let len: usize = [
510 !Vec::is_empty(&self.r#away_team) as usize,
511 !Vec::is_empty(&self.r#competitor) as usize,
512 !Vec::is_empty(&self.r#home_team) as usize,
513 !Vec::is_empty(&self.r#sport) as usize,
514 !Vec::is_empty(&self.r#about) as usize,
515 !Vec::is_empty(&self.r#actor) as usize,
516 !Vec::is_empty(&self.r#aggregate_rating) as usize,
517 !Vec::is_empty(&self.r#attendee) as usize,
518 !Vec::is_empty(&self.r#attendees) as usize,
519 !Vec::is_empty(&self.r#audience) as usize,
520 !Vec::is_empty(&self.r#composer) as usize,
521 !Vec::is_empty(&self.r#contributor) as usize,
522 !Vec::is_empty(&self.r#director) as usize,
523 !Vec::is_empty(&self.r#door_time) as usize,
524 !Vec::is_empty(&self.r#duration) as usize,
525 !Vec::is_empty(&self.r#end_date) as usize,
526 !Vec::is_empty(&self.r#event_attendance_mode) as usize,
527 !Vec::is_empty(&self.r#event_schedule) as usize,
528 !Vec::is_empty(&self.r#event_status) as usize,
529 !Vec::is_empty(&self.r#funder) as usize,
530 !Vec::is_empty(&self.r#funding) as usize,
531 !Vec::is_empty(&self.r#in_language) as usize,
532 !Vec::is_empty(&self.r#is_accessible_for_free) as usize,
533 !Vec::is_empty(&self.r#keywords) as usize,
534 !Vec::is_empty(&self.r#location) as usize,
535 !Vec::is_empty(&self.r#maximum_attendee_capacity) as usize,
536 !Vec::is_empty(&self.r#maximum_physical_attendee_capacity) as usize,
537 !Vec::is_empty(&self.r#maximum_virtual_attendee_capacity) as usize,
538 !Vec::is_empty(&self.r#offers) as usize,
539 !Vec::is_empty(&self.r#organizer) as usize,
540 !Vec::is_empty(&self.r#performer) as usize,
541 !Vec::is_empty(&self.r#performers) as usize,
542 !Vec::is_empty(&self.r#previous_start_date) as usize,
543 !Vec::is_empty(&self.r#recorded_in) as usize,
544 !Vec::is_empty(&self.r#remaining_attendee_capacity) as usize,
545 !Vec::is_empty(&self.r#review) as usize,
546 !Vec::is_empty(&self.r#sponsor) as usize,
547 !Vec::is_empty(&self.r#start_date) as usize,
548 !Vec::is_empty(&self.r#sub_event) as usize,
549 !Vec::is_empty(&self.r#sub_events) as usize,
550 !Vec::is_empty(&self.r#super_event) as usize,
551 !Vec::is_empty(&self.r#translator) as usize,
552 !Vec::is_empty(&self.r#typical_age_range) as usize,
553 !Vec::is_empty(&self.r#work_featured) as usize,
554 !Vec::is_empty(&self.r#work_performed) as usize,
555 !Vec::is_empty(&self.r#additional_type) as usize,
556 !Vec::is_empty(&self.r#alternate_name) as usize,
557 !Vec::is_empty(&self.r#description) as usize,
558 !Vec::is_empty(&self.r#disambiguating_description) as usize,
559 !Vec::is_empty(&self.r#identifier) as usize,
560 !Vec::is_empty(&self.r#image) as usize,
561 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
562 !Vec::is_empty(&self.r#name) as usize,
563 !Vec::is_empty(&self.r#potential_action) as usize,
564 !Vec::is_empty(&self.r#same_as) as usize,
565 !Vec::is_empty(&self.r#subject_of) as usize,
566 !Vec::is_empty(&self.r#url) as usize,
567 ]
568 .iter()
569 .sum();
570 let mut serialize_struct =
571 Serializer::serialize_struct(serializer, "SportsEvent", len)?;
572 if !Vec::is_empty(&self.r#away_team) {
573 serialize_struct.serialize_field("awayTeam", {
574 struct SerializeWith<'a>(&'a Vec<AwayTeamProperty>);
575 impl<'a> Serialize for SerializeWith<'a> {
576 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
577 where
578 S: Serializer,
579 {
580 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
581 self.0, serializer,
582 )
583 }
584 }
585 &SerializeWith(&self.r#away_team)
586 })?;
587 } else {
588 serialize_struct.skip_field("awayTeam")?;
589 }
590 if !Vec::is_empty(&self.r#competitor) {
591 serialize_struct.serialize_field("competitor", {
592 struct SerializeWith<'a>(&'a Vec<CompetitorProperty>);
593 impl<'a> Serialize for SerializeWith<'a> {
594 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
595 where
596 S: Serializer,
597 {
598 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
599 self.0, serializer,
600 )
601 }
602 }
603 &SerializeWith(&self.r#competitor)
604 })?;
605 } else {
606 serialize_struct.skip_field("competitor")?;
607 }
608 if !Vec::is_empty(&self.r#home_team) {
609 serialize_struct.serialize_field("homeTeam", {
610 struct SerializeWith<'a>(&'a Vec<HomeTeamProperty>);
611 impl<'a> Serialize for SerializeWith<'a> {
612 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
613 where
614 S: Serializer,
615 {
616 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
617 self.0, serializer,
618 )
619 }
620 }
621 &SerializeWith(&self.r#home_team)
622 })?;
623 } else {
624 serialize_struct.skip_field("homeTeam")?;
625 }
626 if !Vec::is_empty(&self.r#sport) {
627 serialize_struct.serialize_field("sport", {
628 struct SerializeWith<'a>(&'a Vec<SportProperty>);
629 impl<'a> Serialize for SerializeWith<'a> {
630 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
631 where
632 S: Serializer,
633 {
634 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
635 self.0, serializer,
636 )
637 }
638 }
639 &SerializeWith(&self.r#sport)
640 })?;
641 } else {
642 serialize_struct.skip_field("sport")?;
643 }
644 if !Vec::is_empty(&self.r#about) {
645 serialize_struct.serialize_field("about", {
646 struct SerializeWith<'a>(&'a Vec<AboutProperty>);
647 impl<'a> Serialize for SerializeWith<'a> {
648 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
649 where
650 S: Serializer,
651 {
652 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
653 self.0, serializer,
654 )
655 }
656 }
657 &SerializeWith(&self.r#about)
658 })?;
659 } else {
660 serialize_struct.skip_field("about")?;
661 }
662 if !Vec::is_empty(&self.r#actor) {
663 serialize_struct.serialize_field("actor", {
664 struct SerializeWith<'a>(&'a Vec<ActorProperty>);
665 impl<'a> Serialize for SerializeWith<'a> {
666 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
667 where
668 S: Serializer,
669 {
670 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
671 self.0, serializer,
672 )
673 }
674 }
675 &SerializeWith(&self.r#actor)
676 })?;
677 } else {
678 serialize_struct.skip_field("actor")?;
679 }
680 if !Vec::is_empty(&self.r#aggregate_rating) {
681 serialize_struct.serialize_field("aggregateRating", {
682 struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
683 impl<'a> Serialize for SerializeWith<'a> {
684 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
685 where
686 S: Serializer,
687 {
688 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
689 self.0, serializer,
690 )
691 }
692 }
693 &SerializeWith(&self.r#aggregate_rating)
694 })?;
695 } else {
696 serialize_struct.skip_field("aggregateRating")?;
697 }
698 if !Vec::is_empty(&self.r#attendee) {
699 serialize_struct.serialize_field("attendee", {
700 struct SerializeWith<'a>(&'a Vec<AttendeeProperty>);
701 impl<'a> Serialize for SerializeWith<'a> {
702 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
703 where
704 S: Serializer,
705 {
706 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
707 self.0, serializer,
708 )
709 }
710 }
711 &SerializeWith(&self.r#attendee)
712 })?;
713 } else {
714 serialize_struct.skip_field("attendee")?;
715 }
716 if !Vec::is_empty(&self.r#attendees) {
717 serialize_struct.serialize_field("attendees", {
718 struct SerializeWith<'a>(&'a Vec<AttendeesProperty>);
719 impl<'a> Serialize for SerializeWith<'a> {
720 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
721 where
722 S: Serializer,
723 {
724 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
725 self.0, serializer,
726 )
727 }
728 }
729 &SerializeWith(&self.r#attendees)
730 })?;
731 } else {
732 serialize_struct.skip_field("attendees")?;
733 }
734 if !Vec::is_empty(&self.r#audience) {
735 serialize_struct.serialize_field("audience", {
736 struct SerializeWith<'a>(&'a Vec<AudienceProperty>);
737 impl<'a> Serialize for SerializeWith<'a> {
738 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
739 where
740 S: Serializer,
741 {
742 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
743 self.0, serializer,
744 )
745 }
746 }
747 &SerializeWith(&self.r#audience)
748 })?;
749 } else {
750 serialize_struct.skip_field("audience")?;
751 }
752 if !Vec::is_empty(&self.r#composer) {
753 serialize_struct.serialize_field("composer", {
754 struct SerializeWith<'a>(&'a Vec<ComposerProperty>);
755 impl<'a> Serialize for SerializeWith<'a> {
756 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
757 where
758 S: Serializer,
759 {
760 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
761 self.0, serializer,
762 )
763 }
764 }
765 &SerializeWith(&self.r#composer)
766 })?;
767 } else {
768 serialize_struct.skip_field("composer")?;
769 }
770 if !Vec::is_empty(&self.r#contributor) {
771 serialize_struct.serialize_field("contributor", {
772 struct SerializeWith<'a>(&'a Vec<ContributorProperty>);
773 impl<'a> Serialize for SerializeWith<'a> {
774 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
775 where
776 S: Serializer,
777 {
778 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
779 self.0, serializer,
780 )
781 }
782 }
783 &SerializeWith(&self.r#contributor)
784 })?;
785 } else {
786 serialize_struct.skip_field("contributor")?;
787 }
788 if !Vec::is_empty(&self.r#director) {
789 serialize_struct.serialize_field("director", {
790 struct SerializeWith<'a>(&'a Vec<DirectorProperty>);
791 impl<'a> Serialize for SerializeWith<'a> {
792 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
793 where
794 S: Serializer,
795 {
796 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
797 self.0, serializer,
798 )
799 }
800 }
801 &SerializeWith(&self.r#director)
802 })?;
803 } else {
804 serialize_struct.skip_field("director")?;
805 }
806 if !Vec::is_empty(&self.r#door_time) {
807 serialize_struct.serialize_field("doorTime", {
808 struct SerializeWith<'a>(&'a Vec<DoorTimeProperty>);
809 impl<'a> Serialize for SerializeWith<'a> {
810 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
811 where
812 S: Serializer,
813 {
814 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
815 self.0, serializer,
816 )
817 }
818 }
819 &SerializeWith(&self.r#door_time)
820 })?;
821 } else {
822 serialize_struct.skip_field("doorTime")?;
823 }
824 if !Vec::is_empty(&self.r#duration) {
825 serialize_struct.serialize_field("duration", {
826 struct SerializeWith<'a>(&'a Vec<DurationProperty>);
827 impl<'a> Serialize for SerializeWith<'a> {
828 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
829 where
830 S: Serializer,
831 {
832 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
833 self.0, serializer,
834 )
835 }
836 }
837 &SerializeWith(&self.r#duration)
838 })?;
839 } else {
840 serialize_struct.skip_field("duration")?;
841 }
842 if !Vec::is_empty(&self.r#end_date) {
843 serialize_struct.serialize_field("endDate", {
844 struct SerializeWith<'a>(&'a Vec<EndDateProperty>);
845 impl<'a> Serialize for SerializeWith<'a> {
846 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
847 where
848 S: Serializer,
849 {
850 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
851 self.0, serializer,
852 )
853 }
854 }
855 &SerializeWith(&self.r#end_date)
856 })?;
857 } else {
858 serialize_struct.skip_field("endDate")?;
859 }
860 if !Vec::is_empty(&self.r#event_attendance_mode) {
861 serialize_struct.serialize_field("eventAttendanceMode", {
862 struct SerializeWith<'a>(&'a Vec<EventAttendanceModeProperty>);
863 impl<'a> Serialize for SerializeWith<'a> {
864 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
865 where
866 S: Serializer,
867 {
868 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
869 self.0, serializer,
870 )
871 }
872 }
873 &SerializeWith(&self.r#event_attendance_mode)
874 })?;
875 } else {
876 serialize_struct.skip_field("eventAttendanceMode")?;
877 }
878 if !Vec::is_empty(&self.r#event_schedule) {
879 serialize_struct.serialize_field("eventSchedule", {
880 struct SerializeWith<'a>(&'a Vec<EventScheduleProperty>);
881 impl<'a> Serialize for SerializeWith<'a> {
882 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
883 where
884 S: Serializer,
885 {
886 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
887 self.0, serializer,
888 )
889 }
890 }
891 &SerializeWith(&self.r#event_schedule)
892 })?;
893 } else {
894 serialize_struct.skip_field("eventSchedule")?;
895 }
896 if !Vec::is_empty(&self.r#event_status) {
897 serialize_struct.serialize_field("eventStatus", {
898 struct SerializeWith<'a>(&'a Vec<EventStatusProperty>);
899 impl<'a> Serialize for SerializeWith<'a> {
900 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
901 where
902 S: Serializer,
903 {
904 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
905 self.0, serializer,
906 )
907 }
908 }
909 &SerializeWith(&self.r#event_status)
910 })?;
911 } else {
912 serialize_struct.skip_field("eventStatus")?;
913 }
914 if !Vec::is_empty(&self.r#funder) {
915 serialize_struct.serialize_field("funder", {
916 struct SerializeWith<'a>(&'a Vec<FunderProperty>);
917 impl<'a> Serialize for SerializeWith<'a> {
918 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
919 where
920 S: Serializer,
921 {
922 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
923 self.0, serializer,
924 )
925 }
926 }
927 &SerializeWith(&self.r#funder)
928 })?;
929 } else {
930 serialize_struct.skip_field("funder")?;
931 }
932 if !Vec::is_empty(&self.r#funding) {
933 serialize_struct.serialize_field("funding", {
934 struct SerializeWith<'a>(&'a Vec<FundingProperty>);
935 impl<'a> Serialize for SerializeWith<'a> {
936 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
937 where
938 S: Serializer,
939 {
940 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
941 self.0, serializer,
942 )
943 }
944 }
945 &SerializeWith(&self.r#funding)
946 })?;
947 } else {
948 serialize_struct.skip_field("funding")?;
949 }
950 if !Vec::is_empty(&self.r#in_language) {
951 serialize_struct.serialize_field("inLanguage", {
952 struct SerializeWith<'a>(&'a Vec<InLanguageProperty>);
953 impl<'a> Serialize for SerializeWith<'a> {
954 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
955 where
956 S: Serializer,
957 {
958 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
959 self.0, serializer,
960 )
961 }
962 }
963 &SerializeWith(&self.r#in_language)
964 })?;
965 } else {
966 serialize_struct.skip_field("inLanguage")?;
967 }
968 if !Vec::is_empty(&self.r#is_accessible_for_free) {
969 serialize_struct.serialize_field("isAccessibleForFree", {
970 struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
971 impl<'a> Serialize for SerializeWith<'a> {
972 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
973 where
974 S: Serializer,
975 {
976 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
977 self.0, serializer,
978 )
979 }
980 }
981 &SerializeWith(&self.r#is_accessible_for_free)
982 })?;
983 } else {
984 serialize_struct.skip_field("isAccessibleForFree")?;
985 }
986 if !Vec::is_empty(&self.r#keywords) {
987 serialize_struct.serialize_field("keywords", {
988 struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
989 impl<'a> Serialize for SerializeWith<'a> {
990 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
991 where
992 S: Serializer,
993 {
994 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
995 self.0, serializer,
996 )
997 }
998 }
999 &SerializeWith(&self.r#keywords)
1000 })?;
1001 } else {
1002 serialize_struct.skip_field("keywords")?;
1003 }
1004 if !Vec::is_empty(&self.r#location) {
1005 serialize_struct.serialize_field("location", {
1006 struct SerializeWith<'a>(&'a Vec<LocationProperty>);
1007 impl<'a> Serialize for SerializeWith<'a> {
1008 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1009 where
1010 S: Serializer,
1011 {
1012 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1013 self.0, serializer,
1014 )
1015 }
1016 }
1017 &SerializeWith(&self.r#location)
1018 })?;
1019 } else {
1020 serialize_struct.skip_field("location")?;
1021 }
1022 if !Vec::is_empty(&self.r#maximum_attendee_capacity) {
1023 serialize_struct.serialize_field("maximumAttendeeCapacity", {
1024 struct SerializeWith<'a>(&'a Vec<MaximumAttendeeCapacityProperty>);
1025 impl<'a> Serialize for SerializeWith<'a> {
1026 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1027 where
1028 S: Serializer,
1029 {
1030 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1031 self.0, serializer,
1032 )
1033 }
1034 }
1035 &SerializeWith(&self.r#maximum_attendee_capacity)
1036 })?;
1037 } else {
1038 serialize_struct.skip_field("maximumAttendeeCapacity")?;
1039 }
1040 if !Vec::is_empty(&self.r#maximum_physical_attendee_capacity) {
1041 serialize_struct.serialize_field("maximumPhysicalAttendeeCapacity", {
1042 struct SerializeWith<'a>(&'a Vec<MaximumPhysicalAttendeeCapacityProperty>);
1043 impl<'a> Serialize for SerializeWith<'a> {
1044 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1045 where
1046 S: Serializer,
1047 {
1048 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1049 self.0, serializer,
1050 )
1051 }
1052 }
1053 &SerializeWith(&self.r#maximum_physical_attendee_capacity)
1054 })?;
1055 } else {
1056 serialize_struct.skip_field("maximumPhysicalAttendeeCapacity")?;
1057 }
1058 if !Vec::is_empty(&self.r#maximum_virtual_attendee_capacity) {
1059 serialize_struct.serialize_field("maximumVirtualAttendeeCapacity", {
1060 struct SerializeWith<'a>(&'a Vec<MaximumVirtualAttendeeCapacityProperty>);
1061 impl<'a> Serialize for SerializeWith<'a> {
1062 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1063 where
1064 S: Serializer,
1065 {
1066 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1067 self.0, serializer,
1068 )
1069 }
1070 }
1071 &SerializeWith(&self.r#maximum_virtual_attendee_capacity)
1072 })?;
1073 } else {
1074 serialize_struct.skip_field("maximumVirtualAttendeeCapacity")?;
1075 }
1076 if !Vec::is_empty(&self.r#offers) {
1077 serialize_struct.serialize_field("offers", {
1078 struct SerializeWith<'a>(&'a Vec<OffersProperty>);
1079 impl<'a> Serialize for SerializeWith<'a> {
1080 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1081 where
1082 S: Serializer,
1083 {
1084 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1085 self.0, serializer,
1086 )
1087 }
1088 }
1089 &SerializeWith(&self.r#offers)
1090 })?;
1091 } else {
1092 serialize_struct.skip_field("offers")?;
1093 }
1094 if !Vec::is_empty(&self.r#organizer) {
1095 serialize_struct.serialize_field("organizer", {
1096 struct SerializeWith<'a>(&'a Vec<OrganizerProperty>);
1097 impl<'a> Serialize for SerializeWith<'a> {
1098 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1099 where
1100 S: Serializer,
1101 {
1102 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1103 self.0, serializer,
1104 )
1105 }
1106 }
1107 &SerializeWith(&self.r#organizer)
1108 })?;
1109 } else {
1110 serialize_struct.skip_field("organizer")?;
1111 }
1112 if !Vec::is_empty(&self.r#performer) {
1113 serialize_struct.serialize_field("performer", {
1114 struct SerializeWith<'a>(&'a Vec<PerformerProperty>);
1115 impl<'a> Serialize for SerializeWith<'a> {
1116 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1117 where
1118 S: Serializer,
1119 {
1120 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1121 self.0, serializer,
1122 )
1123 }
1124 }
1125 &SerializeWith(&self.r#performer)
1126 })?;
1127 } else {
1128 serialize_struct.skip_field("performer")?;
1129 }
1130 if !Vec::is_empty(&self.r#performers) {
1131 serialize_struct.serialize_field("performers", {
1132 struct SerializeWith<'a>(&'a Vec<PerformersProperty>);
1133 impl<'a> Serialize for SerializeWith<'a> {
1134 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1135 where
1136 S: Serializer,
1137 {
1138 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1139 self.0, serializer,
1140 )
1141 }
1142 }
1143 &SerializeWith(&self.r#performers)
1144 })?;
1145 } else {
1146 serialize_struct.skip_field("performers")?;
1147 }
1148 if !Vec::is_empty(&self.r#previous_start_date) {
1149 serialize_struct.serialize_field("previousStartDate", {
1150 struct SerializeWith<'a>(&'a Vec<PreviousStartDateProperty>);
1151 impl<'a> Serialize for SerializeWith<'a> {
1152 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1153 where
1154 S: Serializer,
1155 {
1156 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1157 self.0, serializer,
1158 )
1159 }
1160 }
1161 &SerializeWith(&self.r#previous_start_date)
1162 })?;
1163 } else {
1164 serialize_struct.skip_field("previousStartDate")?;
1165 }
1166 if !Vec::is_empty(&self.r#recorded_in) {
1167 serialize_struct.serialize_field("recordedIn", {
1168 struct SerializeWith<'a>(&'a Vec<RecordedInProperty>);
1169 impl<'a> Serialize for SerializeWith<'a> {
1170 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1171 where
1172 S: Serializer,
1173 {
1174 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1175 self.0, serializer,
1176 )
1177 }
1178 }
1179 &SerializeWith(&self.r#recorded_in)
1180 })?;
1181 } else {
1182 serialize_struct.skip_field("recordedIn")?;
1183 }
1184 if !Vec::is_empty(&self.r#remaining_attendee_capacity) {
1185 serialize_struct.serialize_field("remainingAttendeeCapacity", {
1186 struct SerializeWith<'a>(&'a Vec<RemainingAttendeeCapacityProperty>);
1187 impl<'a> Serialize for SerializeWith<'a> {
1188 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1189 where
1190 S: Serializer,
1191 {
1192 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1193 self.0, serializer,
1194 )
1195 }
1196 }
1197 &SerializeWith(&self.r#remaining_attendee_capacity)
1198 })?;
1199 } else {
1200 serialize_struct.skip_field("remainingAttendeeCapacity")?;
1201 }
1202 if !Vec::is_empty(&self.r#review) {
1203 serialize_struct.serialize_field("review", {
1204 struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
1205 impl<'a> Serialize for SerializeWith<'a> {
1206 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1207 where
1208 S: Serializer,
1209 {
1210 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1211 self.0, serializer,
1212 )
1213 }
1214 }
1215 &SerializeWith(&self.r#review)
1216 })?;
1217 } else {
1218 serialize_struct.skip_field("review")?;
1219 }
1220 if !Vec::is_empty(&self.r#sponsor) {
1221 serialize_struct.serialize_field("sponsor", {
1222 struct SerializeWith<'a>(&'a Vec<SponsorProperty>);
1223 impl<'a> Serialize for SerializeWith<'a> {
1224 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1225 where
1226 S: Serializer,
1227 {
1228 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1229 self.0, serializer,
1230 )
1231 }
1232 }
1233 &SerializeWith(&self.r#sponsor)
1234 })?;
1235 } else {
1236 serialize_struct.skip_field("sponsor")?;
1237 }
1238 if !Vec::is_empty(&self.r#start_date) {
1239 serialize_struct.serialize_field("startDate", {
1240 struct SerializeWith<'a>(&'a Vec<StartDateProperty>);
1241 impl<'a> Serialize for SerializeWith<'a> {
1242 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1243 where
1244 S: Serializer,
1245 {
1246 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1247 self.0, serializer,
1248 )
1249 }
1250 }
1251 &SerializeWith(&self.r#start_date)
1252 })?;
1253 } else {
1254 serialize_struct.skip_field("startDate")?;
1255 }
1256 if !Vec::is_empty(&self.r#sub_event) {
1257 serialize_struct.serialize_field("subEvent", {
1258 struct SerializeWith<'a>(&'a Vec<SubEventProperty>);
1259 impl<'a> Serialize for SerializeWith<'a> {
1260 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1261 where
1262 S: Serializer,
1263 {
1264 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1265 self.0, serializer,
1266 )
1267 }
1268 }
1269 &SerializeWith(&self.r#sub_event)
1270 })?;
1271 } else {
1272 serialize_struct.skip_field("subEvent")?;
1273 }
1274 if !Vec::is_empty(&self.r#sub_events) {
1275 serialize_struct.serialize_field("subEvents", {
1276 struct SerializeWith<'a>(&'a Vec<SubEventsProperty>);
1277 impl<'a> Serialize for SerializeWith<'a> {
1278 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1279 where
1280 S: Serializer,
1281 {
1282 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1283 self.0, serializer,
1284 )
1285 }
1286 }
1287 &SerializeWith(&self.r#sub_events)
1288 })?;
1289 } else {
1290 serialize_struct.skip_field("subEvents")?;
1291 }
1292 if !Vec::is_empty(&self.r#super_event) {
1293 serialize_struct.serialize_field("superEvent", {
1294 struct SerializeWith<'a>(&'a Vec<SuperEventProperty>);
1295 impl<'a> Serialize for SerializeWith<'a> {
1296 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1297 where
1298 S: Serializer,
1299 {
1300 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1301 self.0, serializer,
1302 )
1303 }
1304 }
1305 &SerializeWith(&self.r#super_event)
1306 })?;
1307 } else {
1308 serialize_struct.skip_field("superEvent")?;
1309 }
1310 if !Vec::is_empty(&self.r#translator) {
1311 serialize_struct.serialize_field("translator", {
1312 struct SerializeWith<'a>(&'a Vec<TranslatorProperty>);
1313 impl<'a> Serialize for SerializeWith<'a> {
1314 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1315 where
1316 S: Serializer,
1317 {
1318 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1319 self.0, serializer,
1320 )
1321 }
1322 }
1323 &SerializeWith(&self.r#translator)
1324 })?;
1325 } else {
1326 serialize_struct.skip_field("translator")?;
1327 }
1328 if !Vec::is_empty(&self.r#typical_age_range) {
1329 serialize_struct.serialize_field("typicalAgeRange", {
1330 struct SerializeWith<'a>(&'a Vec<TypicalAgeRangeProperty>);
1331 impl<'a> Serialize for SerializeWith<'a> {
1332 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1333 where
1334 S: Serializer,
1335 {
1336 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1337 self.0, serializer,
1338 )
1339 }
1340 }
1341 &SerializeWith(&self.r#typical_age_range)
1342 })?;
1343 } else {
1344 serialize_struct.skip_field("typicalAgeRange")?;
1345 }
1346 if !Vec::is_empty(&self.r#work_featured) {
1347 serialize_struct.serialize_field("workFeatured", {
1348 struct SerializeWith<'a>(&'a Vec<WorkFeaturedProperty>);
1349 impl<'a> Serialize for SerializeWith<'a> {
1350 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1351 where
1352 S: Serializer,
1353 {
1354 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1355 self.0, serializer,
1356 )
1357 }
1358 }
1359 &SerializeWith(&self.r#work_featured)
1360 })?;
1361 } else {
1362 serialize_struct.skip_field("workFeatured")?;
1363 }
1364 if !Vec::is_empty(&self.r#work_performed) {
1365 serialize_struct.serialize_field("workPerformed", {
1366 struct SerializeWith<'a>(&'a Vec<WorkPerformedProperty>);
1367 impl<'a> Serialize for SerializeWith<'a> {
1368 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1369 where
1370 S: Serializer,
1371 {
1372 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1373 self.0, serializer,
1374 )
1375 }
1376 }
1377 &SerializeWith(&self.r#work_performed)
1378 })?;
1379 } else {
1380 serialize_struct.skip_field("workPerformed")?;
1381 }
1382 if !Vec::is_empty(&self.r#additional_type) {
1383 serialize_struct.serialize_field("additionalType", {
1384 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
1385 impl<'a> Serialize for SerializeWith<'a> {
1386 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1387 where
1388 S: Serializer,
1389 {
1390 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1391 self.0, serializer,
1392 )
1393 }
1394 }
1395 &SerializeWith(&self.r#additional_type)
1396 })?;
1397 } else {
1398 serialize_struct.skip_field("additionalType")?;
1399 }
1400 if !Vec::is_empty(&self.r#alternate_name) {
1401 serialize_struct.serialize_field("alternateName", {
1402 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
1403 impl<'a> Serialize for SerializeWith<'a> {
1404 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1405 where
1406 S: Serializer,
1407 {
1408 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1409 self.0, serializer,
1410 )
1411 }
1412 }
1413 &SerializeWith(&self.r#alternate_name)
1414 })?;
1415 } else {
1416 serialize_struct.skip_field("alternateName")?;
1417 }
1418 if !Vec::is_empty(&self.r#description) {
1419 serialize_struct.serialize_field("description", {
1420 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
1421 impl<'a> Serialize for SerializeWith<'a> {
1422 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1423 where
1424 S: Serializer,
1425 {
1426 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1427 self.0, serializer,
1428 )
1429 }
1430 }
1431 &SerializeWith(&self.r#description)
1432 })?;
1433 } else {
1434 serialize_struct.skip_field("description")?;
1435 }
1436 if !Vec::is_empty(&self.r#disambiguating_description) {
1437 serialize_struct.serialize_field("disambiguatingDescription", {
1438 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
1439 impl<'a> Serialize for SerializeWith<'a> {
1440 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1441 where
1442 S: Serializer,
1443 {
1444 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1445 self.0, serializer,
1446 )
1447 }
1448 }
1449 &SerializeWith(&self.r#disambiguating_description)
1450 })?;
1451 } else {
1452 serialize_struct.skip_field("disambiguatingDescription")?;
1453 }
1454 if !Vec::is_empty(&self.r#identifier) {
1455 serialize_struct.serialize_field("identifier", {
1456 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
1457 impl<'a> Serialize for SerializeWith<'a> {
1458 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1459 where
1460 S: Serializer,
1461 {
1462 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1463 self.0, serializer,
1464 )
1465 }
1466 }
1467 &SerializeWith(&self.r#identifier)
1468 })?;
1469 } else {
1470 serialize_struct.skip_field("identifier")?;
1471 }
1472 if !Vec::is_empty(&self.r#image) {
1473 serialize_struct.serialize_field("image", {
1474 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
1475 impl<'a> Serialize for SerializeWith<'a> {
1476 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1477 where
1478 S: Serializer,
1479 {
1480 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1481 self.0, serializer,
1482 )
1483 }
1484 }
1485 &SerializeWith(&self.r#image)
1486 })?;
1487 } else {
1488 serialize_struct.skip_field("image")?;
1489 }
1490 if !Vec::is_empty(&self.r#main_entity_of_page) {
1491 serialize_struct.serialize_field("mainEntityOfPage", {
1492 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
1493 impl<'a> Serialize for SerializeWith<'a> {
1494 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1495 where
1496 S: Serializer,
1497 {
1498 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1499 self.0, serializer,
1500 )
1501 }
1502 }
1503 &SerializeWith(&self.r#main_entity_of_page)
1504 })?;
1505 } else {
1506 serialize_struct.skip_field("mainEntityOfPage")?;
1507 }
1508 if !Vec::is_empty(&self.r#name) {
1509 serialize_struct.serialize_field("name", {
1510 struct SerializeWith<'a>(&'a Vec<NameProperty>);
1511 impl<'a> Serialize for SerializeWith<'a> {
1512 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1513 where
1514 S: Serializer,
1515 {
1516 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1517 self.0, serializer,
1518 )
1519 }
1520 }
1521 &SerializeWith(&self.r#name)
1522 })?;
1523 } else {
1524 serialize_struct.skip_field("name")?;
1525 }
1526 if !Vec::is_empty(&self.r#potential_action) {
1527 serialize_struct.serialize_field("potentialAction", {
1528 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
1529 impl<'a> Serialize for SerializeWith<'a> {
1530 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1531 where
1532 S: Serializer,
1533 {
1534 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1535 self.0, serializer,
1536 )
1537 }
1538 }
1539 &SerializeWith(&self.r#potential_action)
1540 })?;
1541 } else {
1542 serialize_struct.skip_field("potentialAction")?;
1543 }
1544 if !Vec::is_empty(&self.r#same_as) {
1545 serialize_struct.serialize_field("sameAs", {
1546 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
1547 impl<'a> Serialize for SerializeWith<'a> {
1548 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1549 where
1550 S: Serializer,
1551 {
1552 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1553 self.0, serializer,
1554 )
1555 }
1556 }
1557 &SerializeWith(&self.r#same_as)
1558 })?;
1559 } else {
1560 serialize_struct.skip_field("sameAs")?;
1561 }
1562 if !Vec::is_empty(&self.r#subject_of) {
1563 serialize_struct.serialize_field("subjectOf", {
1564 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
1565 impl<'a> Serialize for SerializeWith<'a> {
1566 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1567 where
1568 S: Serializer,
1569 {
1570 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1571 self.0, serializer,
1572 )
1573 }
1574 }
1575 &SerializeWith(&self.r#subject_of)
1576 })?;
1577 } else {
1578 serialize_struct.skip_field("subjectOf")?;
1579 }
1580 if !Vec::is_empty(&self.r#url) {
1581 serialize_struct.serialize_field("url", {
1582 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
1583 impl<'a> Serialize for SerializeWith<'a> {
1584 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1585 where
1586 S: Serializer,
1587 {
1588 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1589 self.0, serializer,
1590 )
1591 }
1592 }
1593 &SerializeWith(&self.r#url)
1594 })?;
1595 } else {
1596 serialize_struct.skip_field("url")?;
1597 }
1598 serialize_struct.end()
1599 }
1600 }
1601 impl<'de> Deserialize<'de> for SportsEvent {
1602 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1603 where
1604 D: Deserializer<'de>,
1605 {
1606 enum Field {
1607 AwayTeam,
1608 Competitor,
1609 HomeTeam,
1610 Sport,
1611 About,
1612 Actor,
1613 AggregateRating,
1614 Attendee,
1615 Attendees,
1616 Audience,
1617 Composer,
1618 Contributor,
1619 Director,
1620 DoorTime,
1621 Duration,
1622 EndDate,
1623 EventAttendanceMode,
1624 EventSchedule,
1625 EventStatus,
1626 Funder,
1627 Funding,
1628 InLanguage,
1629 IsAccessibleForFree,
1630 Keywords,
1631 Location,
1632 MaximumAttendeeCapacity,
1633 MaximumPhysicalAttendeeCapacity,
1634 MaximumVirtualAttendeeCapacity,
1635 Offers,
1636 Organizer,
1637 Performer,
1638 Performers,
1639 PreviousStartDate,
1640 RecordedIn,
1641 RemainingAttendeeCapacity,
1642 Review,
1643 Sponsor,
1644 StartDate,
1645 SubEvent,
1646 SubEvents,
1647 SuperEvent,
1648 Translator,
1649 TypicalAgeRange,
1650 WorkFeatured,
1651 WorkPerformed,
1652 AdditionalType,
1653 AlternateName,
1654 Description,
1655 DisambiguatingDescription,
1656 Identifier,
1657 Image,
1658 MainEntityOfPage,
1659 Name,
1660 PotentialAction,
1661 SameAs,
1662 SubjectOf,
1663 Url,
1664 Ignore,
1665 }
1666 struct FieldVisitor;
1667 impl<'de> Visitor<'de> for FieldVisitor {
1668 type Value = Field;
1669 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1670 formatter.write_str("field identifier")
1671 }
1672 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1673 where
1674 E: de::Error,
1675 {
1676 match value {
1677 "awayTeam" => Ok(Field::AwayTeam),
1678 "competitor" => Ok(Field::Competitor),
1679 "homeTeam" => Ok(Field::HomeTeam),
1680 "sport" => Ok(Field::Sport),
1681 "about" => Ok(Field::About),
1682 "actor" => Ok(Field::Actor),
1683 "aggregateRating" => Ok(Field::AggregateRating),
1684 "attendee" => Ok(Field::Attendee),
1685 "attendees" => Ok(Field::Attendees),
1686 "audience" => Ok(Field::Audience),
1687 "composer" => Ok(Field::Composer),
1688 "contributor" => Ok(Field::Contributor),
1689 "director" => Ok(Field::Director),
1690 "doorTime" => Ok(Field::DoorTime),
1691 "duration" => Ok(Field::Duration),
1692 "endDate" => Ok(Field::EndDate),
1693 "eventAttendanceMode" => Ok(Field::EventAttendanceMode),
1694 "eventSchedule" => Ok(Field::EventSchedule),
1695 "eventStatus" => Ok(Field::EventStatus),
1696 "funder" => Ok(Field::Funder),
1697 "funding" => Ok(Field::Funding),
1698 "inLanguage" => Ok(Field::InLanguage),
1699 "isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
1700 "keywords" => Ok(Field::Keywords),
1701 "location" => Ok(Field::Location),
1702 "maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
1703 "maximumPhysicalAttendeeCapacity" => {
1704 Ok(Field::MaximumPhysicalAttendeeCapacity)
1705 }
1706 "maximumVirtualAttendeeCapacity" => {
1707 Ok(Field::MaximumVirtualAttendeeCapacity)
1708 }
1709 "offers" => Ok(Field::Offers),
1710 "organizer" => Ok(Field::Organizer),
1711 "performer" => Ok(Field::Performer),
1712 "performers" => Ok(Field::Performers),
1713 "previousStartDate" => Ok(Field::PreviousStartDate),
1714 "recordedIn" => Ok(Field::RecordedIn),
1715 "remainingAttendeeCapacity" => Ok(Field::RemainingAttendeeCapacity),
1716 "review" => Ok(Field::Review),
1717 "sponsor" => Ok(Field::Sponsor),
1718 "startDate" => Ok(Field::StartDate),
1719 "subEvent" => Ok(Field::SubEvent),
1720 "subEvents" => Ok(Field::SubEvents),
1721 "superEvent" => Ok(Field::SuperEvent),
1722 "translator" => Ok(Field::Translator),
1723 "typicalAgeRange" => Ok(Field::TypicalAgeRange),
1724 "workFeatured" => Ok(Field::WorkFeatured),
1725 "workPerformed" => Ok(Field::WorkPerformed),
1726 "additionalType" => Ok(Field::AdditionalType),
1727 "alternateName" => Ok(Field::AlternateName),
1728 "description" => Ok(Field::Description),
1729 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1730 "identifier" => Ok(Field::Identifier),
1731 "image" => Ok(Field::Image),
1732 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1733 "name" => Ok(Field::Name),
1734 "potentialAction" => Ok(Field::PotentialAction),
1735 "sameAs" => Ok(Field::SameAs),
1736 "subjectOf" => Ok(Field::SubjectOf),
1737 "url" => Ok(Field::Url),
1738 "id" | "type" => Ok(Field::Ignore),
1739 _ => Err(de::Error::unknown_field(value, FIELDS)),
1740 }
1741 }
1742 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1743 where
1744 E: de::Error,
1745 {
1746 match value {
1747 b"awayTeam" => Ok(Field::AwayTeam),
1748 b"competitor" => Ok(Field::Competitor),
1749 b"homeTeam" => Ok(Field::HomeTeam),
1750 b"sport" => Ok(Field::Sport),
1751 b"about" => Ok(Field::About),
1752 b"actor" => Ok(Field::Actor),
1753 b"aggregateRating" => Ok(Field::AggregateRating),
1754 b"attendee" => Ok(Field::Attendee),
1755 b"attendees" => Ok(Field::Attendees),
1756 b"audience" => Ok(Field::Audience),
1757 b"composer" => Ok(Field::Composer),
1758 b"contributor" => Ok(Field::Contributor),
1759 b"director" => Ok(Field::Director),
1760 b"doorTime" => Ok(Field::DoorTime),
1761 b"duration" => Ok(Field::Duration),
1762 b"endDate" => Ok(Field::EndDate),
1763 b"eventAttendanceMode" => Ok(Field::EventAttendanceMode),
1764 b"eventSchedule" => Ok(Field::EventSchedule),
1765 b"eventStatus" => Ok(Field::EventStatus),
1766 b"funder" => Ok(Field::Funder),
1767 b"funding" => Ok(Field::Funding),
1768 b"inLanguage" => Ok(Field::InLanguage),
1769 b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
1770 b"keywords" => Ok(Field::Keywords),
1771 b"location" => Ok(Field::Location),
1772 b"maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
1773 b"maximumPhysicalAttendeeCapacity" => {
1774 Ok(Field::MaximumPhysicalAttendeeCapacity)
1775 }
1776 b"maximumVirtualAttendeeCapacity" => {
1777 Ok(Field::MaximumVirtualAttendeeCapacity)
1778 }
1779 b"offers" => Ok(Field::Offers),
1780 b"organizer" => Ok(Field::Organizer),
1781 b"performer" => Ok(Field::Performer),
1782 b"performers" => Ok(Field::Performers),
1783 b"previousStartDate" => Ok(Field::PreviousStartDate),
1784 b"recordedIn" => Ok(Field::RecordedIn),
1785 b"remainingAttendeeCapacity" => Ok(Field::RemainingAttendeeCapacity),
1786 b"review" => Ok(Field::Review),
1787 b"sponsor" => Ok(Field::Sponsor),
1788 b"startDate" => Ok(Field::StartDate),
1789 b"subEvent" => Ok(Field::SubEvent),
1790 b"subEvents" => Ok(Field::SubEvents),
1791 b"superEvent" => Ok(Field::SuperEvent),
1792 b"translator" => Ok(Field::Translator),
1793 b"typicalAgeRange" => Ok(Field::TypicalAgeRange),
1794 b"workFeatured" => Ok(Field::WorkFeatured),
1795 b"workPerformed" => Ok(Field::WorkPerformed),
1796 b"additionalType" => Ok(Field::AdditionalType),
1797 b"alternateName" => Ok(Field::AlternateName),
1798 b"description" => Ok(Field::Description),
1799 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1800 b"identifier" => Ok(Field::Identifier),
1801 b"image" => Ok(Field::Image),
1802 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1803 b"name" => Ok(Field::Name),
1804 b"potentialAction" => Ok(Field::PotentialAction),
1805 b"sameAs" => Ok(Field::SameAs),
1806 b"subjectOf" => Ok(Field::SubjectOf),
1807 b"url" => Ok(Field::Url),
1808 b"id" | b"type" => Ok(Field::Ignore),
1809 _ => {
1810 let value = &String::from_utf8_lossy(value);
1811 Err(de::Error::unknown_field(value, FIELDS))
1812 }
1813 }
1814 }
1815 }
1816 impl<'de> Deserialize<'de> for Field {
1817 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1818 where
1819 D: Deserializer<'de>,
1820 {
1821 deserializer.deserialize_identifier(FieldVisitor)
1822 }
1823 }
1824 struct ClassVisitor;
1825 impl<'de> Visitor<'de> for ClassVisitor {
1826 type Value = SportsEvent;
1827 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1828 formatter.write_str("schema.org schema SportsEvent")
1829 }
1830 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1831 where
1832 A: de::MapAccess<'de>,
1833 {
1834 let mut r#away_team_property = None;
1835 let mut r#competitor_property = None;
1836 let mut r#home_team_property = None;
1837 let mut r#sport_property = None;
1838 let mut r#about_property = None;
1839 let mut r#actor_property = None;
1840 let mut r#aggregate_rating_property = None;
1841 let mut r#attendee_property = None;
1842 let mut r#attendees_property = None;
1843 let mut r#audience_property = None;
1844 let mut r#composer_property = None;
1845 let mut r#contributor_property = None;
1846 let mut r#director_property = None;
1847 let mut r#door_time_property = None;
1848 let mut r#duration_property = None;
1849 let mut r#end_date_property = None;
1850 let mut r#event_attendance_mode_property = None;
1851 let mut r#event_schedule_property = None;
1852 let mut r#event_status_property = None;
1853 let mut r#funder_property = None;
1854 let mut r#funding_property = None;
1855 let mut r#in_language_property = None;
1856 let mut r#is_accessible_for_free_property = None;
1857 let mut r#keywords_property = None;
1858 let mut r#location_property = None;
1859 let mut r#maximum_attendee_capacity_property = None;
1860 let mut r#maximum_physical_attendee_capacity_property = None;
1861 let mut r#maximum_virtual_attendee_capacity_property = None;
1862 let mut r#offers_property = None;
1863 let mut r#organizer_property = None;
1864 let mut r#performer_property = None;
1865 let mut r#performers_property = None;
1866 let mut r#previous_start_date_property = None;
1867 let mut r#recorded_in_property = None;
1868 let mut r#remaining_attendee_capacity_property = None;
1869 let mut r#review_property = None;
1870 let mut r#sponsor_property = None;
1871 let mut r#start_date_property = None;
1872 let mut r#sub_event_property = None;
1873 let mut r#sub_events_property = None;
1874 let mut r#super_event_property = None;
1875 let mut r#translator_property = None;
1876 let mut r#typical_age_range_property = None;
1877 let mut r#work_featured_property = None;
1878 let mut r#work_performed_property = None;
1879 let mut r#additional_type_property = None;
1880 let mut r#alternate_name_property = None;
1881 let mut r#description_property = None;
1882 let mut r#disambiguating_description_property = None;
1883 let mut r#identifier_property = None;
1884 let mut r#image_property = None;
1885 let mut r#main_entity_of_page_property = None;
1886 let mut r#name_property = None;
1887 let mut r#potential_action_property = None;
1888 let mut r#same_as_property = None;
1889 let mut r#subject_of_property = None;
1890 let mut r#url_property = None;
1891 while let Some(key) = map.next_key::<Field>()? {
1892 match key {
1893 Field::AwayTeam => {
1894 if r#away_team_property.is_some() {
1895 return Err(<A::Error as de::Error>::duplicate_field(
1896 "awayTeam",
1897 ));
1898 }
1899 r#away_team_property = Some({
1900 struct DeserializeWith(Vec<AwayTeamProperty>);
1901 impl<'de> Deserialize<'de> for DeserializeWith {
1902 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1903 where
1904 D: Deserializer<'de>,
1905 {
1906 Ok(DeserializeWith(serde_with::As::<
1907 serde_with::OneOrMany<serde_with::Same>,
1908 >::deserialize(deserializer)?))
1909 }
1910 }
1911 match map.next_value::<DeserializeWith>() {
1912 Ok(deserialize_with) => deserialize_with.0,
1913 Err(err) => {
1914 return Err(err);
1915 }
1916 }
1917 });
1918 }
1919 Field::Competitor => {
1920 if r#competitor_property.is_some() {
1921 return Err(<A::Error as de::Error>::duplicate_field(
1922 "competitor",
1923 ));
1924 }
1925 r#competitor_property = Some({
1926 struct DeserializeWith(Vec<CompetitorProperty>);
1927 impl<'de> Deserialize<'de> for DeserializeWith {
1928 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1929 where
1930 D: Deserializer<'de>,
1931 {
1932 Ok(DeserializeWith(serde_with::As::<
1933 serde_with::OneOrMany<serde_with::Same>,
1934 >::deserialize(deserializer)?))
1935 }
1936 }
1937 match map.next_value::<DeserializeWith>() {
1938 Ok(deserialize_with) => deserialize_with.0,
1939 Err(err) => {
1940 return Err(err);
1941 }
1942 }
1943 });
1944 }
1945 Field::HomeTeam => {
1946 if r#home_team_property.is_some() {
1947 return Err(<A::Error as de::Error>::duplicate_field(
1948 "homeTeam",
1949 ));
1950 }
1951 r#home_team_property = Some({
1952 struct DeserializeWith(Vec<HomeTeamProperty>);
1953 impl<'de> Deserialize<'de> for DeserializeWith {
1954 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1955 where
1956 D: Deserializer<'de>,
1957 {
1958 Ok(DeserializeWith(serde_with::As::<
1959 serde_with::OneOrMany<serde_with::Same>,
1960 >::deserialize(deserializer)?))
1961 }
1962 }
1963 match map.next_value::<DeserializeWith>() {
1964 Ok(deserialize_with) => deserialize_with.0,
1965 Err(err) => {
1966 return Err(err);
1967 }
1968 }
1969 });
1970 }
1971 Field::Sport => {
1972 if r#sport_property.is_some() {
1973 return Err(<A::Error as de::Error>::duplicate_field("sport"));
1974 }
1975 r#sport_property = Some({
1976 struct DeserializeWith(Vec<SportProperty>);
1977 impl<'de> Deserialize<'de> for DeserializeWith {
1978 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1979 where
1980 D: Deserializer<'de>,
1981 {
1982 Ok(DeserializeWith(serde_with::As::<
1983 serde_with::OneOrMany<serde_with::Same>,
1984 >::deserialize(deserializer)?))
1985 }
1986 }
1987 match map.next_value::<DeserializeWith>() {
1988 Ok(deserialize_with) => deserialize_with.0,
1989 Err(err) => {
1990 return Err(err);
1991 }
1992 }
1993 });
1994 }
1995 Field::About => {
1996 if r#about_property.is_some() {
1997 return Err(<A::Error as de::Error>::duplicate_field("about"));
1998 }
1999 r#about_property = Some({
2000 struct DeserializeWith(Vec<AboutProperty>);
2001 impl<'de> Deserialize<'de> for DeserializeWith {
2002 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2003 where
2004 D: Deserializer<'de>,
2005 {
2006 Ok(DeserializeWith(serde_with::As::<
2007 serde_with::OneOrMany<serde_with::Same>,
2008 >::deserialize(deserializer)?))
2009 }
2010 }
2011 match map.next_value::<DeserializeWith>() {
2012 Ok(deserialize_with) => deserialize_with.0,
2013 Err(err) => {
2014 return Err(err);
2015 }
2016 }
2017 });
2018 }
2019 Field::Actor => {
2020 if r#actor_property.is_some() {
2021 return Err(<A::Error as de::Error>::duplicate_field("actor"));
2022 }
2023 r#actor_property = Some({
2024 struct DeserializeWith(Vec<ActorProperty>);
2025 impl<'de> Deserialize<'de> for DeserializeWith {
2026 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2027 where
2028 D: Deserializer<'de>,
2029 {
2030 Ok(DeserializeWith(serde_with::As::<
2031 serde_with::OneOrMany<serde_with::Same>,
2032 >::deserialize(deserializer)?))
2033 }
2034 }
2035 match map.next_value::<DeserializeWith>() {
2036 Ok(deserialize_with) => deserialize_with.0,
2037 Err(err) => {
2038 return Err(err);
2039 }
2040 }
2041 });
2042 }
2043 Field::AggregateRating => {
2044 if r#aggregate_rating_property.is_some() {
2045 return Err(<A::Error as de::Error>::duplicate_field(
2046 "aggregateRating",
2047 ));
2048 }
2049 r#aggregate_rating_property = Some({
2050 struct DeserializeWith(Vec<AggregateRatingProperty>);
2051 impl<'de> Deserialize<'de> for DeserializeWith {
2052 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2053 where
2054 D: Deserializer<'de>,
2055 {
2056 Ok(DeserializeWith(serde_with::As::<
2057 serde_with::OneOrMany<serde_with::Same>,
2058 >::deserialize(deserializer)?))
2059 }
2060 }
2061 match map.next_value::<DeserializeWith>() {
2062 Ok(deserialize_with) => deserialize_with.0,
2063 Err(err) => {
2064 return Err(err);
2065 }
2066 }
2067 });
2068 }
2069 Field::Attendee => {
2070 if r#attendee_property.is_some() {
2071 return Err(<A::Error as de::Error>::duplicate_field(
2072 "attendee",
2073 ));
2074 }
2075 r#attendee_property = Some({
2076 struct DeserializeWith(Vec<AttendeeProperty>);
2077 impl<'de> Deserialize<'de> for DeserializeWith {
2078 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2079 where
2080 D: Deserializer<'de>,
2081 {
2082 Ok(DeserializeWith(serde_with::As::<
2083 serde_with::OneOrMany<serde_with::Same>,
2084 >::deserialize(deserializer)?))
2085 }
2086 }
2087 match map.next_value::<DeserializeWith>() {
2088 Ok(deserialize_with) => deserialize_with.0,
2089 Err(err) => {
2090 return Err(err);
2091 }
2092 }
2093 });
2094 }
2095 Field::Attendees => {
2096 if r#attendees_property.is_some() {
2097 return Err(<A::Error as de::Error>::duplicate_field(
2098 "attendees",
2099 ));
2100 }
2101 r#attendees_property = Some({
2102 struct DeserializeWith(Vec<AttendeesProperty>);
2103 impl<'de> Deserialize<'de> for DeserializeWith {
2104 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2105 where
2106 D: Deserializer<'de>,
2107 {
2108 Ok(DeserializeWith(serde_with::As::<
2109 serde_with::OneOrMany<serde_with::Same>,
2110 >::deserialize(deserializer)?))
2111 }
2112 }
2113 match map.next_value::<DeserializeWith>() {
2114 Ok(deserialize_with) => deserialize_with.0,
2115 Err(err) => {
2116 return Err(err);
2117 }
2118 }
2119 });
2120 }
2121 Field::Audience => {
2122 if r#audience_property.is_some() {
2123 return Err(<A::Error as de::Error>::duplicate_field(
2124 "audience",
2125 ));
2126 }
2127 r#audience_property = Some({
2128 struct DeserializeWith(Vec<AudienceProperty>);
2129 impl<'de> Deserialize<'de> for DeserializeWith {
2130 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2131 where
2132 D: Deserializer<'de>,
2133 {
2134 Ok(DeserializeWith(serde_with::As::<
2135 serde_with::OneOrMany<serde_with::Same>,
2136 >::deserialize(deserializer)?))
2137 }
2138 }
2139 match map.next_value::<DeserializeWith>() {
2140 Ok(deserialize_with) => deserialize_with.0,
2141 Err(err) => {
2142 return Err(err);
2143 }
2144 }
2145 });
2146 }
2147 Field::Composer => {
2148 if r#composer_property.is_some() {
2149 return Err(<A::Error as de::Error>::duplicate_field(
2150 "composer",
2151 ));
2152 }
2153 r#composer_property = Some({
2154 struct DeserializeWith(Vec<ComposerProperty>);
2155 impl<'de> Deserialize<'de> for DeserializeWith {
2156 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2157 where
2158 D: Deserializer<'de>,
2159 {
2160 Ok(DeserializeWith(serde_with::As::<
2161 serde_with::OneOrMany<serde_with::Same>,
2162 >::deserialize(deserializer)?))
2163 }
2164 }
2165 match map.next_value::<DeserializeWith>() {
2166 Ok(deserialize_with) => deserialize_with.0,
2167 Err(err) => {
2168 return Err(err);
2169 }
2170 }
2171 });
2172 }
2173 Field::Contributor => {
2174 if r#contributor_property.is_some() {
2175 return Err(<A::Error as de::Error>::duplicate_field(
2176 "contributor",
2177 ));
2178 }
2179 r#contributor_property = Some({
2180 struct DeserializeWith(Vec<ContributorProperty>);
2181 impl<'de> Deserialize<'de> for DeserializeWith {
2182 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2183 where
2184 D: Deserializer<'de>,
2185 {
2186 Ok(DeserializeWith(serde_with::As::<
2187 serde_with::OneOrMany<serde_with::Same>,
2188 >::deserialize(deserializer)?))
2189 }
2190 }
2191 match map.next_value::<DeserializeWith>() {
2192 Ok(deserialize_with) => deserialize_with.0,
2193 Err(err) => {
2194 return Err(err);
2195 }
2196 }
2197 });
2198 }
2199 Field::Director => {
2200 if r#director_property.is_some() {
2201 return Err(<A::Error as de::Error>::duplicate_field(
2202 "director",
2203 ));
2204 }
2205 r#director_property = Some({
2206 struct DeserializeWith(Vec<DirectorProperty>);
2207 impl<'de> Deserialize<'de> for DeserializeWith {
2208 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2209 where
2210 D: Deserializer<'de>,
2211 {
2212 Ok(DeserializeWith(serde_with::As::<
2213 serde_with::OneOrMany<serde_with::Same>,
2214 >::deserialize(deserializer)?))
2215 }
2216 }
2217 match map.next_value::<DeserializeWith>() {
2218 Ok(deserialize_with) => deserialize_with.0,
2219 Err(err) => {
2220 return Err(err);
2221 }
2222 }
2223 });
2224 }
2225 Field::DoorTime => {
2226 if r#door_time_property.is_some() {
2227 return Err(<A::Error as de::Error>::duplicate_field(
2228 "doorTime",
2229 ));
2230 }
2231 r#door_time_property = Some({
2232 struct DeserializeWith(Vec<DoorTimeProperty>);
2233 impl<'de> Deserialize<'de> for DeserializeWith {
2234 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2235 where
2236 D: Deserializer<'de>,
2237 {
2238 Ok(DeserializeWith(serde_with::As::<
2239 serde_with::OneOrMany<serde_with::Same>,
2240 >::deserialize(deserializer)?))
2241 }
2242 }
2243 match map.next_value::<DeserializeWith>() {
2244 Ok(deserialize_with) => deserialize_with.0,
2245 Err(err) => {
2246 return Err(err);
2247 }
2248 }
2249 });
2250 }
2251 Field::Duration => {
2252 if r#duration_property.is_some() {
2253 return Err(<A::Error as de::Error>::duplicate_field(
2254 "duration",
2255 ));
2256 }
2257 r#duration_property = Some({
2258 struct DeserializeWith(Vec<DurationProperty>);
2259 impl<'de> Deserialize<'de> for DeserializeWith {
2260 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2261 where
2262 D: Deserializer<'de>,
2263 {
2264 Ok(DeserializeWith(serde_with::As::<
2265 serde_with::OneOrMany<serde_with::Same>,
2266 >::deserialize(deserializer)?))
2267 }
2268 }
2269 match map.next_value::<DeserializeWith>() {
2270 Ok(deserialize_with) => deserialize_with.0,
2271 Err(err) => {
2272 return Err(err);
2273 }
2274 }
2275 });
2276 }
2277 Field::EndDate => {
2278 if r#end_date_property.is_some() {
2279 return Err(<A::Error as de::Error>::duplicate_field(
2280 "endDate",
2281 ));
2282 }
2283 r#end_date_property = Some({
2284 struct DeserializeWith(Vec<EndDateProperty>);
2285 impl<'de> Deserialize<'de> for DeserializeWith {
2286 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2287 where
2288 D: Deserializer<'de>,
2289 {
2290 Ok(DeserializeWith(serde_with::As::<
2291 serde_with::OneOrMany<serde_with::Same>,
2292 >::deserialize(deserializer)?))
2293 }
2294 }
2295 match map.next_value::<DeserializeWith>() {
2296 Ok(deserialize_with) => deserialize_with.0,
2297 Err(err) => {
2298 return Err(err);
2299 }
2300 }
2301 });
2302 }
2303 Field::EventAttendanceMode => {
2304 if r#event_attendance_mode_property.is_some() {
2305 return Err(<A::Error as de::Error>::duplicate_field(
2306 "eventAttendanceMode",
2307 ));
2308 }
2309 r#event_attendance_mode_property = Some({
2310 struct DeserializeWith(Vec<EventAttendanceModeProperty>);
2311 impl<'de> Deserialize<'de> for DeserializeWith {
2312 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2313 where
2314 D: Deserializer<'de>,
2315 {
2316 Ok(DeserializeWith(serde_with::As::<
2317 serde_with::OneOrMany<serde_with::Same>,
2318 >::deserialize(deserializer)?))
2319 }
2320 }
2321 match map.next_value::<DeserializeWith>() {
2322 Ok(deserialize_with) => deserialize_with.0,
2323 Err(err) => {
2324 return Err(err);
2325 }
2326 }
2327 });
2328 }
2329 Field::EventSchedule => {
2330 if r#event_schedule_property.is_some() {
2331 return Err(<A::Error as de::Error>::duplicate_field(
2332 "eventSchedule",
2333 ));
2334 }
2335 r#event_schedule_property = Some({
2336 struct DeserializeWith(Vec<EventScheduleProperty>);
2337 impl<'de> Deserialize<'de> for DeserializeWith {
2338 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2339 where
2340 D: Deserializer<'de>,
2341 {
2342 Ok(DeserializeWith(serde_with::As::<
2343 serde_with::OneOrMany<serde_with::Same>,
2344 >::deserialize(deserializer)?))
2345 }
2346 }
2347 match map.next_value::<DeserializeWith>() {
2348 Ok(deserialize_with) => deserialize_with.0,
2349 Err(err) => {
2350 return Err(err);
2351 }
2352 }
2353 });
2354 }
2355 Field::EventStatus => {
2356 if r#event_status_property.is_some() {
2357 return Err(<A::Error as de::Error>::duplicate_field(
2358 "eventStatus",
2359 ));
2360 }
2361 r#event_status_property = Some({
2362 struct DeserializeWith(Vec<EventStatusProperty>);
2363 impl<'de> Deserialize<'de> for DeserializeWith {
2364 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2365 where
2366 D: Deserializer<'de>,
2367 {
2368 Ok(DeserializeWith(serde_with::As::<
2369 serde_with::OneOrMany<serde_with::Same>,
2370 >::deserialize(deserializer)?))
2371 }
2372 }
2373 match map.next_value::<DeserializeWith>() {
2374 Ok(deserialize_with) => deserialize_with.0,
2375 Err(err) => {
2376 return Err(err);
2377 }
2378 }
2379 });
2380 }
2381 Field::Funder => {
2382 if r#funder_property.is_some() {
2383 return Err(<A::Error as de::Error>::duplicate_field("funder"));
2384 }
2385 r#funder_property = Some({
2386 struct DeserializeWith(Vec<FunderProperty>);
2387 impl<'de> Deserialize<'de> for DeserializeWith {
2388 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2389 where
2390 D: Deserializer<'de>,
2391 {
2392 Ok(DeserializeWith(serde_with::As::<
2393 serde_with::OneOrMany<serde_with::Same>,
2394 >::deserialize(deserializer)?))
2395 }
2396 }
2397 match map.next_value::<DeserializeWith>() {
2398 Ok(deserialize_with) => deserialize_with.0,
2399 Err(err) => {
2400 return Err(err);
2401 }
2402 }
2403 });
2404 }
2405 Field::Funding => {
2406 if r#funding_property.is_some() {
2407 return Err(<A::Error as de::Error>::duplicate_field(
2408 "funding",
2409 ));
2410 }
2411 r#funding_property = Some({
2412 struct DeserializeWith(Vec<FundingProperty>);
2413 impl<'de> Deserialize<'de> for DeserializeWith {
2414 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2415 where
2416 D: Deserializer<'de>,
2417 {
2418 Ok(DeserializeWith(serde_with::As::<
2419 serde_with::OneOrMany<serde_with::Same>,
2420 >::deserialize(deserializer)?))
2421 }
2422 }
2423 match map.next_value::<DeserializeWith>() {
2424 Ok(deserialize_with) => deserialize_with.0,
2425 Err(err) => {
2426 return Err(err);
2427 }
2428 }
2429 });
2430 }
2431 Field::InLanguage => {
2432 if r#in_language_property.is_some() {
2433 return Err(<A::Error as de::Error>::duplicate_field(
2434 "inLanguage",
2435 ));
2436 }
2437 r#in_language_property = Some({
2438 struct DeserializeWith(Vec<InLanguageProperty>);
2439 impl<'de> Deserialize<'de> for DeserializeWith {
2440 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2441 where
2442 D: Deserializer<'de>,
2443 {
2444 Ok(DeserializeWith(serde_with::As::<
2445 serde_with::OneOrMany<serde_with::Same>,
2446 >::deserialize(deserializer)?))
2447 }
2448 }
2449 match map.next_value::<DeserializeWith>() {
2450 Ok(deserialize_with) => deserialize_with.0,
2451 Err(err) => {
2452 return Err(err);
2453 }
2454 }
2455 });
2456 }
2457 Field::IsAccessibleForFree => {
2458 if r#is_accessible_for_free_property.is_some() {
2459 return Err(<A::Error as de::Error>::duplicate_field(
2460 "isAccessibleForFree",
2461 ));
2462 }
2463 r#is_accessible_for_free_property = Some({
2464 struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
2465 impl<'de> Deserialize<'de> for DeserializeWith {
2466 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2467 where
2468 D: Deserializer<'de>,
2469 {
2470 Ok(DeserializeWith(serde_with::As::<
2471 serde_with::OneOrMany<serde_with::Same>,
2472 >::deserialize(deserializer)?))
2473 }
2474 }
2475 match map.next_value::<DeserializeWith>() {
2476 Ok(deserialize_with) => deserialize_with.0,
2477 Err(err) => {
2478 return Err(err);
2479 }
2480 }
2481 });
2482 }
2483 Field::Keywords => {
2484 if r#keywords_property.is_some() {
2485 return Err(<A::Error as de::Error>::duplicate_field(
2486 "keywords",
2487 ));
2488 }
2489 r#keywords_property = Some({
2490 struct DeserializeWith(Vec<KeywordsProperty>);
2491 impl<'de> Deserialize<'de> for DeserializeWith {
2492 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2493 where
2494 D: Deserializer<'de>,
2495 {
2496 Ok(DeserializeWith(serde_with::As::<
2497 serde_with::OneOrMany<serde_with::Same>,
2498 >::deserialize(deserializer)?))
2499 }
2500 }
2501 match map.next_value::<DeserializeWith>() {
2502 Ok(deserialize_with) => deserialize_with.0,
2503 Err(err) => {
2504 return Err(err);
2505 }
2506 }
2507 });
2508 }
2509 Field::Location => {
2510 if r#location_property.is_some() {
2511 return Err(<A::Error as de::Error>::duplicate_field(
2512 "location",
2513 ));
2514 }
2515 r#location_property = Some({
2516 struct DeserializeWith(Vec<LocationProperty>);
2517 impl<'de> Deserialize<'de> for DeserializeWith {
2518 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2519 where
2520 D: Deserializer<'de>,
2521 {
2522 Ok(DeserializeWith(serde_with::As::<
2523 serde_with::OneOrMany<serde_with::Same>,
2524 >::deserialize(deserializer)?))
2525 }
2526 }
2527 match map.next_value::<DeserializeWith>() {
2528 Ok(deserialize_with) => deserialize_with.0,
2529 Err(err) => {
2530 return Err(err);
2531 }
2532 }
2533 });
2534 }
2535 Field::MaximumAttendeeCapacity => {
2536 if r#maximum_attendee_capacity_property.is_some() {
2537 return Err(<A::Error as de::Error>::duplicate_field(
2538 "maximumAttendeeCapacity",
2539 ));
2540 }
2541 r#maximum_attendee_capacity_property = Some({
2542 struct DeserializeWith(Vec<MaximumAttendeeCapacityProperty>);
2543 impl<'de> Deserialize<'de> for DeserializeWith {
2544 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2545 where
2546 D: Deserializer<'de>,
2547 {
2548 Ok(DeserializeWith(serde_with::As::<
2549 serde_with::OneOrMany<serde_with::Same>,
2550 >::deserialize(deserializer)?))
2551 }
2552 }
2553 match map.next_value::<DeserializeWith>() {
2554 Ok(deserialize_with) => deserialize_with.0,
2555 Err(err) => {
2556 return Err(err);
2557 }
2558 }
2559 });
2560 }
2561 Field::MaximumPhysicalAttendeeCapacity => {
2562 if r#maximum_physical_attendee_capacity_property.is_some() {
2563 return Err(<A::Error as de::Error>::duplicate_field(
2564 "maximumPhysicalAttendeeCapacity",
2565 ));
2566 }
2567 r#maximum_physical_attendee_capacity_property = Some({
2568 struct DeserializeWith(
2569 Vec<MaximumPhysicalAttendeeCapacityProperty>,
2570 );
2571 impl<'de> Deserialize<'de> for DeserializeWith {
2572 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2573 where
2574 D: Deserializer<'de>,
2575 {
2576 Ok(DeserializeWith(serde_with::As::<
2577 serde_with::OneOrMany<serde_with::Same>,
2578 >::deserialize(deserializer)?))
2579 }
2580 }
2581 match map.next_value::<DeserializeWith>() {
2582 Ok(deserialize_with) => deserialize_with.0,
2583 Err(err) => {
2584 return Err(err);
2585 }
2586 }
2587 });
2588 }
2589 Field::MaximumVirtualAttendeeCapacity => {
2590 if r#maximum_virtual_attendee_capacity_property.is_some() {
2591 return Err(<A::Error as de::Error>::duplicate_field(
2592 "maximumVirtualAttendeeCapacity",
2593 ));
2594 }
2595 r#maximum_virtual_attendee_capacity_property = Some({
2596 struct DeserializeWith(
2597 Vec<MaximumVirtualAttendeeCapacityProperty>,
2598 );
2599 impl<'de> Deserialize<'de> for DeserializeWith {
2600 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2601 where
2602 D: Deserializer<'de>,
2603 {
2604 Ok(DeserializeWith(serde_with::As::<
2605 serde_with::OneOrMany<serde_with::Same>,
2606 >::deserialize(deserializer)?))
2607 }
2608 }
2609 match map.next_value::<DeserializeWith>() {
2610 Ok(deserialize_with) => deserialize_with.0,
2611 Err(err) => {
2612 return Err(err);
2613 }
2614 }
2615 });
2616 }
2617 Field::Offers => {
2618 if r#offers_property.is_some() {
2619 return Err(<A::Error as de::Error>::duplicate_field("offers"));
2620 }
2621 r#offers_property = Some({
2622 struct DeserializeWith(Vec<OffersProperty>);
2623 impl<'de> Deserialize<'de> for DeserializeWith {
2624 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2625 where
2626 D: Deserializer<'de>,
2627 {
2628 Ok(DeserializeWith(serde_with::As::<
2629 serde_with::OneOrMany<serde_with::Same>,
2630 >::deserialize(deserializer)?))
2631 }
2632 }
2633 match map.next_value::<DeserializeWith>() {
2634 Ok(deserialize_with) => deserialize_with.0,
2635 Err(err) => {
2636 return Err(err);
2637 }
2638 }
2639 });
2640 }
2641 Field::Organizer => {
2642 if r#organizer_property.is_some() {
2643 return Err(<A::Error as de::Error>::duplicate_field(
2644 "organizer",
2645 ));
2646 }
2647 r#organizer_property = Some({
2648 struct DeserializeWith(Vec<OrganizerProperty>);
2649 impl<'de> Deserialize<'de> for DeserializeWith {
2650 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2651 where
2652 D: Deserializer<'de>,
2653 {
2654 Ok(DeserializeWith(serde_with::As::<
2655 serde_with::OneOrMany<serde_with::Same>,
2656 >::deserialize(deserializer)?))
2657 }
2658 }
2659 match map.next_value::<DeserializeWith>() {
2660 Ok(deserialize_with) => deserialize_with.0,
2661 Err(err) => {
2662 return Err(err);
2663 }
2664 }
2665 });
2666 }
2667 Field::Performer => {
2668 if r#performer_property.is_some() {
2669 return Err(<A::Error as de::Error>::duplicate_field(
2670 "performer",
2671 ));
2672 }
2673 r#performer_property = Some({
2674 struct DeserializeWith(Vec<PerformerProperty>);
2675 impl<'de> Deserialize<'de> for DeserializeWith {
2676 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2677 where
2678 D: Deserializer<'de>,
2679 {
2680 Ok(DeserializeWith(serde_with::As::<
2681 serde_with::OneOrMany<serde_with::Same>,
2682 >::deserialize(deserializer)?))
2683 }
2684 }
2685 match map.next_value::<DeserializeWith>() {
2686 Ok(deserialize_with) => deserialize_with.0,
2687 Err(err) => {
2688 return Err(err);
2689 }
2690 }
2691 });
2692 }
2693 Field::Performers => {
2694 if r#performers_property.is_some() {
2695 return Err(<A::Error as de::Error>::duplicate_field(
2696 "performers",
2697 ));
2698 }
2699 r#performers_property = Some({
2700 struct DeserializeWith(Vec<PerformersProperty>);
2701 impl<'de> Deserialize<'de> for DeserializeWith {
2702 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2703 where
2704 D: Deserializer<'de>,
2705 {
2706 Ok(DeserializeWith(serde_with::As::<
2707 serde_with::OneOrMany<serde_with::Same>,
2708 >::deserialize(deserializer)?))
2709 }
2710 }
2711 match map.next_value::<DeserializeWith>() {
2712 Ok(deserialize_with) => deserialize_with.0,
2713 Err(err) => {
2714 return Err(err);
2715 }
2716 }
2717 });
2718 }
2719 Field::PreviousStartDate => {
2720 if r#previous_start_date_property.is_some() {
2721 return Err(<A::Error as de::Error>::duplicate_field(
2722 "previousStartDate",
2723 ));
2724 }
2725 r#previous_start_date_property = Some({
2726 struct DeserializeWith(Vec<PreviousStartDateProperty>);
2727 impl<'de> Deserialize<'de> for DeserializeWith {
2728 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2729 where
2730 D: Deserializer<'de>,
2731 {
2732 Ok(DeserializeWith(serde_with::As::<
2733 serde_with::OneOrMany<serde_with::Same>,
2734 >::deserialize(deserializer)?))
2735 }
2736 }
2737 match map.next_value::<DeserializeWith>() {
2738 Ok(deserialize_with) => deserialize_with.0,
2739 Err(err) => {
2740 return Err(err);
2741 }
2742 }
2743 });
2744 }
2745 Field::RecordedIn => {
2746 if r#recorded_in_property.is_some() {
2747 return Err(<A::Error as de::Error>::duplicate_field(
2748 "recordedIn",
2749 ));
2750 }
2751 r#recorded_in_property = Some({
2752 struct DeserializeWith(Vec<RecordedInProperty>);
2753 impl<'de> Deserialize<'de> for DeserializeWith {
2754 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2755 where
2756 D: Deserializer<'de>,
2757 {
2758 Ok(DeserializeWith(serde_with::As::<
2759 serde_with::OneOrMany<serde_with::Same>,
2760 >::deserialize(deserializer)?))
2761 }
2762 }
2763 match map.next_value::<DeserializeWith>() {
2764 Ok(deserialize_with) => deserialize_with.0,
2765 Err(err) => {
2766 return Err(err);
2767 }
2768 }
2769 });
2770 }
2771 Field::RemainingAttendeeCapacity => {
2772 if r#remaining_attendee_capacity_property.is_some() {
2773 return Err(<A::Error as de::Error>::duplicate_field(
2774 "remainingAttendeeCapacity",
2775 ));
2776 }
2777 r#remaining_attendee_capacity_property = Some({
2778 struct DeserializeWith(Vec<RemainingAttendeeCapacityProperty>);
2779 impl<'de> Deserialize<'de> for DeserializeWith {
2780 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2781 where
2782 D: Deserializer<'de>,
2783 {
2784 Ok(DeserializeWith(serde_with::As::<
2785 serde_with::OneOrMany<serde_with::Same>,
2786 >::deserialize(deserializer)?))
2787 }
2788 }
2789 match map.next_value::<DeserializeWith>() {
2790 Ok(deserialize_with) => deserialize_with.0,
2791 Err(err) => {
2792 return Err(err);
2793 }
2794 }
2795 });
2796 }
2797 Field::Review => {
2798 if r#review_property.is_some() {
2799 return Err(<A::Error as de::Error>::duplicate_field("review"));
2800 }
2801 r#review_property = Some({
2802 struct DeserializeWith(Vec<ReviewProperty>);
2803 impl<'de> Deserialize<'de> for DeserializeWith {
2804 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2805 where
2806 D: Deserializer<'de>,
2807 {
2808 Ok(DeserializeWith(serde_with::As::<
2809 serde_with::OneOrMany<serde_with::Same>,
2810 >::deserialize(deserializer)?))
2811 }
2812 }
2813 match map.next_value::<DeserializeWith>() {
2814 Ok(deserialize_with) => deserialize_with.0,
2815 Err(err) => {
2816 return Err(err);
2817 }
2818 }
2819 });
2820 }
2821 Field::Sponsor => {
2822 if r#sponsor_property.is_some() {
2823 return Err(<A::Error as de::Error>::duplicate_field(
2824 "sponsor",
2825 ));
2826 }
2827 r#sponsor_property = Some({
2828 struct DeserializeWith(Vec<SponsorProperty>);
2829 impl<'de> Deserialize<'de> for DeserializeWith {
2830 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2831 where
2832 D: Deserializer<'de>,
2833 {
2834 Ok(DeserializeWith(serde_with::As::<
2835 serde_with::OneOrMany<serde_with::Same>,
2836 >::deserialize(deserializer)?))
2837 }
2838 }
2839 match map.next_value::<DeserializeWith>() {
2840 Ok(deserialize_with) => deserialize_with.0,
2841 Err(err) => {
2842 return Err(err);
2843 }
2844 }
2845 });
2846 }
2847 Field::StartDate => {
2848 if r#start_date_property.is_some() {
2849 return Err(<A::Error as de::Error>::duplicate_field(
2850 "startDate",
2851 ));
2852 }
2853 r#start_date_property = Some({
2854 struct DeserializeWith(Vec<StartDateProperty>);
2855 impl<'de> Deserialize<'de> for DeserializeWith {
2856 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2857 where
2858 D: Deserializer<'de>,
2859 {
2860 Ok(DeserializeWith(serde_with::As::<
2861 serde_with::OneOrMany<serde_with::Same>,
2862 >::deserialize(deserializer)?))
2863 }
2864 }
2865 match map.next_value::<DeserializeWith>() {
2866 Ok(deserialize_with) => deserialize_with.0,
2867 Err(err) => {
2868 return Err(err);
2869 }
2870 }
2871 });
2872 }
2873 Field::SubEvent => {
2874 if r#sub_event_property.is_some() {
2875 return Err(<A::Error as de::Error>::duplicate_field(
2876 "subEvent",
2877 ));
2878 }
2879 r#sub_event_property = Some({
2880 struct DeserializeWith(Vec<SubEventProperty>);
2881 impl<'de> Deserialize<'de> for DeserializeWith {
2882 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2883 where
2884 D: Deserializer<'de>,
2885 {
2886 Ok(DeserializeWith(serde_with::As::<
2887 serde_with::OneOrMany<serde_with::Same>,
2888 >::deserialize(deserializer)?))
2889 }
2890 }
2891 match map.next_value::<DeserializeWith>() {
2892 Ok(deserialize_with) => deserialize_with.0,
2893 Err(err) => {
2894 return Err(err);
2895 }
2896 }
2897 });
2898 }
2899 Field::SubEvents => {
2900 if r#sub_events_property.is_some() {
2901 return Err(<A::Error as de::Error>::duplicate_field(
2902 "subEvents",
2903 ));
2904 }
2905 r#sub_events_property = Some({
2906 struct DeserializeWith(Vec<SubEventsProperty>);
2907 impl<'de> Deserialize<'de> for DeserializeWith {
2908 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2909 where
2910 D: Deserializer<'de>,
2911 {
2912 Ok(DeserializeWith(serde_with::As::<
2913 serde_with::OneOrMany<serde_with::Same>,
2914 >::deserialize(deserializer)?))
2915 }
2916 }
2917 match map.next_value::<DeserializeWith>() {
2918 Ok(deserialize_with) => deserialize_with.0,
2919 Err(err) => {
2920 return Err(err);
2921 }
2922 }
2923 });
2924 }
2925 Field::SuperEvent => {
2926 if r#super_event_property.is_some() {
2927 return Err(<A::Error as de::Error>::duplicate_field(
2928 "superEvent",
2929 ));
2930 }
2931 r#super_event_property = Some({
2932 struct DeserializeWith(Vec<SuperEventProperty>);
2933 impl<'de> Deserialize<'de> for DeserializeWith {
2934 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2935 where
2936 D: Deserializer<'de>,
2937 {
2938 Ok(DeserializeWith(serde_with::As::<
2939 serde_with::OneOrMany<serde_with::Same>,
2940 >::deserialize(deserializer)?))
2941 }
2942 }
2943 match map.next_value::<DeserializeWith>() {
2944 Ok(deserialize_with) => deserialize_with.0,
2945 Err(err) => {
2946 return Err(err);
2947 }
2948 }
2949 });
2950 }
2951 Field::Translator => {
2952 if r#translator_property.is_some() {
2953 return Err(<A::Error as de::Error>::duplicate_field(
2954 "translator",
2955 ));
2956 }
2957 r#translator_property = Some({
2958 struct DeserializeWith(Vec<TranslatorProperty>);
2959 impl<'de> Deserialize<'de> for DeserializeWith {
2960 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2961 where
2962 D: Deserializer<'de>,
2963 {
2964 Ok(DeserializeWith(serde_with::As::<
2965 serde_with::OneOrMany<serde_with::Same>,
2966 >::deserialize(deserializer)?))
2967 }
2968 }
2969 match map.next_value::<DeserializeWith>() {
2970 Ok(deserialize_with) => deserialize_with.0,
2971 Err(err) => {
2972 return Err(err);
2973 }
2974 }
2975 });
2976 }
2977 Field::TypicalAgeRange => {
2978 if r#typical_age_range_property.is_some() {
2979 return Err(<A::Error as de::Error>::duplicate_field(
2980 "typicalAgeRange",
2981 ));
2982 }
2983 r#typical_age_range_property = Some({
2984 struct DeserializeWith(Vec<TypicalAgeRangeProperty>);
2985 impl<'de> Deserialize<'de> for DeserializeWith {
2986 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2987 where
2988 D: Deserializer<'de>,
2989 {
2990 Ok(DeserializeWith(serde_with::As::<
2991 serde_with::OneOrMany<serde_with::Same>,
2992 >::deserialize(deserializer)?))
2993 }
2994 }
2995 match map.next_value::<DeserializeWith>() {
2996 Ok(deserialize_with) => deserialize_with.0,
2997 Err(err) => {
2998 return Err(err);
2999 }
3000 }
3001 });
3002 }
3003 Field::WorkFeatured => {
3004 if r#work_featured_property.is_some() {
3005 return Err(<A::Error as de::Error>::duplicate_field(
3006 "workFeatured",
3007 ));
3008 }
3009 r#work_featured_property = Some({
3010 struct DeserializeWith(Vec<WorkFeaturedProperty>);
3011 impl<'de> Deserialize<'de> for DeserializeWith {
3012 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3013 where
3014 D: Deserializer<'de>,
3015 {
3016 Ok(DeserializeWith(serde_with::As::<
3017 serde_with::OneOrMany<serde_with::Same>,
3018 >::deserialize(deserializer)?))
3019 }
3020 }
3021 match map.next_value::<DeserializeWith>() {
3022 Ok(deserialize_with) => deserialize_with.0,
3023 Err(err) => {
3024 return Err(err);
3025 }
3026 }
3027 });
3028 }
3029 Field::WorkPerformed => {
3030 if r#work_performed_property.is_some() {
3031 return Err(<A::Error as de::Error>::duplicate_field(
3032 "workPerformed",
3033 ));
3034 }
3035 r#work_performed_property = Some({
3036 struct DeserializeWith(Vec<WorkPerformedProperty>);
3037 impl<'de> Deserialize<'de> for DeserializeWith {
3038 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3039 where
3040 D: Deserializer<'de>,
3041 {
3042 Ok(DeserializeWith(serde_with::As::<
3043 serde_with::OneOrMany<serde_with::Same>,
3044 >::deserialize(deserializer)?))
3045 }
3046 }
3047 match map.next_value::<DeserializeWith>() {
3048 Ok(deserialize_with) => deserialize_with.0,
3049 Err(err) => {
3050 return Err(err);
3051 }
3052 }
3053 });
3054 }
3055 Field::AdditionalType => {
3056 if r#additional_type_property.is_some() {
3057 return Err(<A::Error as de::Error>::duplicate_field(
3058 "additionalType",
3059 ));
3060 }
3061 r#additional_type_property = Some({
3062 struct DeserializeWith(Vec<AdditionalTypeProperty>);
3063 impl<'de> Deserialize<'de> for DeserializeWith {
3064 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3065 where
3066 D: Deserializer<'de>,
3067 {
3068 Ok(DeserializeWith(serde_with::As::<
3069 serde_with::OneOrMany<serde_with::Same>,
3070 >::deserialize(deserializer)?))
3071 }
3072 }
3073 match map.next_value::<DeserializeWith>() {
3074 Ok(deserialize_with) => deserialize_with.0,
3075 Err(err) => {
3076 return Err(err);
3077 }
3078 }
3079 });
3080 }
3081 Field::AlternateName => {
3082 if r#alternate_name_property.is_some() {
3083 return Err(<A::Error as de::Error>::duplicate_field(
3084 "alternateName",
3085 ));
3086 }
3087 r#alternate_name_property = Some({
3088 struct DeserializeWith(Vec<AlternateNameProperty>);
3089 impl<'de> Deserialize<'de> for DeserializeWith {
3090 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3091 where
3092 D: Deserializer<'de>,
3093 {
3094 Ok(DeserializeWith(serde_with::As::<
3095 serde_with::OneOrMany<serde_with::Same>,
3096 >::deserialize(deserializer)?))
3097 }
3098 }
3099 match map.next_value::<DeserializeWith>() {
3100 Ok(deserialize_with) => deserialize_with.0,
3101 Err(err) => {
3102 return Err(err);
3103 }
3104 }
3105 });
3106 }
3107 Field::Description => {
3108 if r#description_property.is_some() {
3109 return Err(<A::Error as de::Error>::duplicate_field(
3110 "description",
3111 ));
3112 }
3113 r#description_property = Some({
3114 struct DeserializeWith(Vec<DescriptionProperty>);
3115 impl<'de> Deserialize<'de> for DeserializeWith {
3116 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3117 where
3118 D: Deserializer<'de>,
3119 {
3120 Ok(DeserializeWith(serde_with::As::<
3121 serde_with::OneOrMany<serde_with::Same>,
3122 >::deserialize(deserializer)?))
3123 }
3124 }
3125 match map.next_value::<DeserializeWith>() {
3126 Ok(deserialize_with) => deserialize_with.0,
3127 Err(err) => {
3128 return Err(err);
3129 }
3130 }
3131 });
3132 }
3133 Field::DisambiguatingDescription => {
3134 if r#disambiguating_description_property.is_some() {
3135 return Err(<A::Error as de::Error>::duplicate_field(
3136 "disambiguatingDescription",
3137 ));
3138 }
3139 r#disambiguating_description_property = Some({
3140 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
3141 impl<'de> Deserialize<'de> for DeserializeWith {
3142 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3143 where
3144 D: Deserializer<'de>,
3145 {
3146 Ok(DeserializeWith(serde_with::As::<
3147 serde_with::OneOrMany<serde_with::Same>,
3148 >::deserialize(deserializer)?))
3149 }
3150 }
3151 match map.next_value::<DeserializeWith>() {
3152 Ok(deserialize_with) => deserialize_with.0,
3153 Err(err) => {
3154 return Err(err);
3155 }
3156 }
3157 });
3158 }
3159 Field::Identifier => {
3160 if r#identifier_property.is_some() {
3161 return Err(<A::Error as de::Error>::duplicate_field(
3162 "identifier",
3163 ));
3164 }
3165 r#identifier_property = Some({
3166 struct DeserializeWith(Vec<IdentifierProperty>);
3167 impl<'de> Deserialize<'de> for DeserializeWith {
3168 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3169 where
3170 D: Deserializer<'de>,
3171 {
3172 Ok(DeserializeWith(serde_with::As::<
3173 serde_with::OneOrMany<serde_with::Same>,
3174 >::deserialize(deserializer)?))
3175 }
3176 }
3177 match map.next_value::<DeserializeWith>() {
3178 Ok(deserialize_with) => deserialize_with.0,
3179 Err(err) => {
3180 return Err(err);
3181 }
3182 }
3183 });
3184 }
3185 Field::Image => {
3186 if r#image_property.is_some() {
3187 return Err(<A::Error as de::Error>::duplicate_field("image"));
3188 }
3189 r#image_property = Some({
3190 struct DeserializeWith(Vec<ImageProperty>);
3191 impl<'de> Deserialize<'de> for DeserializeWith {
3192 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3193 where
3194 D: Deserializer<'de>,
3195 {
3196 Ok(DeserializeWith(serde_with::As::<
3197 serde_with::OneOrMany<serde_with::Same>,
3198 >::deserialize(deserializer)?))
3199 }
3200 }
3201 match map.next_value::<DeserializeWith>() {
3202 Ok(deserialize_with) => deserialize_with.0,
3203 Err(err) => {
3204 return Err(err);
3205 }
3206 }
3207 });
3208 }
3209 Field::MainEntityOfPage => {
3210 if r#main_entity_of_page_property.is_some() {
3211 return Err(<A::Error as de::Error>::duplicate_field(
3212 "mainEntityOfPage",
3213 ));
3214 }
3215 r#main_entity_of_page_property = Some({
3216 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
3217 impl<'de> Deserialize<'de> for DeserializeWith {
3218 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3219 where
3220 D: Deserializer<'de>,
3221 {
3222 Ok(DeserializeWith(serde_with::As::<
3223 serde_with::OneOrMany<serde_with::Same>,
3224 >::deserialize(deserializer)?))
3225 }
3226 }
3227 match map.next_value::<DeserializeWith>() {
3228 Ok(deserialize_with) => deserialize_with.0,
3229 Err(err) => {
3230 return Err(err);
3231 }
3232 }
3233 });
3234 }
3235 Field::Name => {
3236 if r#name_property.is_some() {
3237 return Err(<A::Error as de::Error>::duplicate_field("name"));
3238 }
3239 r#name_property = Some({
3240 struct DeserializeWith(Vec<NameProperty>);
3241 impl<'de> Deserialize<'de> for DeserializeWith {
3242 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3243 where
3244 D: Deserializer<'de>,
3245 {
3246 Ok(DeserializeWith(serde_with::As::<
3247 serde_with::OneOrMany<serde_with::Same>,
3248 >::deserialize(deserializer)?))
3249 }
3250 }
3251 match map.next_value::<DeserializeWith>() {
3252 Ok(deserialize_with) => deserialize_with.0,
3253 Err(err) => {
3254 return Err(err);
3255 }
3256 }
3257 });
3258 }
3259 Field::PotentialAction => {
3260 if r#potential_action_property.is_some() {
3261 return Err(<A::Error as de::Error>::duplicate_field(
3262 "potentialAction",
3263 ));
3264 }
3265 r#potential_action_property = Some({
3266 struct DeserializeWith(Vec<PotentialActionProperty>);
3267 impl<'de> Deserialize<'de> for DeserializeWith {
3268 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3269 where
3270 D: Deserializer<'de>,
3271 {
3272 Ok(DeserializeWith(serde_with::As::<
3273 serde_with::OneOrMany<serde_with::Same>,
3274 >::deserialize(deserializer)?))
3275 }
3276 }
3277 match map.next_value::<DeserializeWith>() {
3278 Ok(deserialize_with) => deserialize_with.0,
3279 Err(err) => {
3280 return Err(err);
3281 }
3282 }
3283 });
3284 }
3285 Field::SameAs => {
3286 if r#same_as_property.is_some() {
3287 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
3288 }
3289 r#same_as_property = Some({
3290 struct DeserializeWith(Vec<SameAsProperty>);
3291 impl<'de> Deserialize<'de> for DeserializeWith {
3292 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3293 where
3294 D: Deserializer<'de>,
3295 {
3296 Ok(DeserializeWith(serde_with::As::<
3297 serde_with::OneOrMany<serde_with::Same>,
3298 >::deserialize(deserializer)?))
3299 }
3300 }
3301 match map.next_value::<DeserializeWith>() {
3302 Ok(deserialize_with) => deserialize_with.0,
3303 Err(err) => {
3304 return Err(err);
3305 }
3306 }
3307 });
3308 }
3309 Field::SubjectOf => {
3310 if r#subject_of_property.is_some() {
3311 return Err(<A::Error as de::Error>::duplicate_field(
3312 "subjectOf",
3313 ));
3314 }
3315 r#subject_of_property = Some({
3316 struct DeserializeWith(Vec<SubjectOfProperty>);
3317 impl<'de> Deserialize<'de> for DeserializeWith {
3318 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3319 where
3320 D: Deserializer<'de>,
3321 {
3322 Ok(DeserializeWith(serde_with::As::<
3323 serde_with::OneOrMany<serde_with::Same>,
3324 >::deserialize(deserializer)?))
3325 }
3326 }
3327 match map.next_value::<DeserializeWith>() {
3328 Ok(deserialize_with) => deserialize_with.0,
3329 Err(err) => {
3330 return Err(err);
3331 }
3332 }
3333 });
3334 }
3335 Field::Url => {
3336 if r#url_property.is_some() {
3337 return Err(<A::Error as de::Error>::duplicate_field("url"));
3338 }
3339 r#url_property = Some({
3340 struct DeserializeWith(Vec<UrlProperty>);
3341 impl<'de> Deserialize<'de> for DeserializeWith {
3342 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3343 where
3344 D: Deserializer<'de>,
3345 {
3346 Ok(DeserializeWith(serde_with::As::<
3347 serde_with::OneOrMany<serde_with::Same>,
3348 >::deserialize(deserializer)?))
3349 }
3350 }
3351 match map.next_value::<DeserializeWith>() {
3352 Ok(deserialize_with) => deserialize_with.0,
3353 Err(err) => {
3354 return Err(err);
3355 }
3356 }
3357 });
3358 }
3359 Field::Ignore => {
3360 let _ = map.next_value::<de::IgnoredAny>()?;
3361 }
3362 }
3363 }
3364 Ok(SportsEvent {
3365 r#away_team: r#away_team_property.unwrap_or_default(),
3366 r#competitor: r#competitor_property.unwrap_or_default(),
3367 r#home_team: r#home_team_property.unwrap_or_default(),
3368 r#sport: r#sport_property.unwrap_or_default(),
3369 r#about: r#about_property.unwrap_or_default(),
3370 r#actor: r#actor_property.unwrap_or_default(),
3371 r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
3372 r#attendee: r#attendee_property.unwrap_or_default(),
3373 r#attendees: r#attendees_property.unwrap_or_default(),
3374 r#audience: r#audience_property.unwrap_or_default(),
3375 r#composer: r#composer_property.unwrap_or_default(),
3376 r#contributor: r#contributor_property.unwrap_or_default(),
3377 r#director: r#director_property.unwrap_or_default(),
3378 r#door_time: r#door_time_property.unwrap_or_default(),
3379 r#duration: r#duration_property.unwrap_or_default(),
3380 r#end_date: r#end_date_property.unwrap_or_default(),
3381 r#event_attendance_mode: r#event_attendance_mode_property
3382 .unwrap_or_default(),
3383 r#event_schedule: r#event_schedule_property.unwrap_or_default(),
3384 r#event_status: r#event_status_property.unwrap_or_default(),
3385 r#funder: r#funder_property.unwrap_or_default(),
3386 r#funding: r#funding_property.unwrap_or_default(),
3387 r#in_language: r#in_language_property.unwrap_or_default(),
3388 r#is_accessible_for_free: r#is_accessible_for_free_property
3389 .unwrap_or_default(),
3390 r#keywords: r#keywords_property.unwrap_or_default(),
3391 r#location: r#location_property.unwrap_or_default(),
3392 r#maximum_attendee_capacity: r#maximum_attendee_capacity_property
3393 .unwrap_or_default(),
3394 r#maximum_physical_attendee_capacity:
3395 r#maximum_physical_attendee_capacity_property.unwrap_or_default(),
3396 r#maximum_virtual_attendee_capacity:
3397 r#maximum_virtual_attendee_capacity_property.unwrap_or_default(),
3398 r#offers: r#offers_property.unwrap_or_default(),
3399 r#organizer: r#organizer_property.unwrap_or_default(),
3400 r#performer: r#performer_property.unwrap_or_default(),
3401 r#performers: r#performers_property.unwrap_or_default(),
3402 r#previous_start_date: r#previous_start_date_property.unwrap_or_default(),
3403 r#recorded_in: r#recorded_in_property.unwrap_or_default(),
3404 r#remaining_attendee_capacity: r#remaining_attendee_capacity_property
3405 .unwrap_or_default(),
3406 r#review: r#review_property.unwrap_or_default(),
3407 r#sponsor: r#sponsor_property.unwrap_or_default(),
3408 r#start_date: r#start_date_property.unwrap_or_default(),
3409 r#sub_event: r#sub_event_property.unwrap_or_default(),
3410 r#sub_events: r#sub_events_property.unwrap_or_default(),
3411 r#super_event: r#super_event_property.unwrap_or_default(),
3412 r#translator: r#translator_property.unwrap_or_default(),
3413 r#typical_age_range: r#typical_age_range_property.unwrap_or_default(),
3414 r#work_featured: r#work_featured_property.unwrap_or_default(),
3415 r#work_performed: r#work_performed_property.unwrap_or_default(),
3416 r#additional_type: r#additional_type_property.unwrap_or_default(),
3417 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
3418 r#description: r#description_property.unwrap_or_default(),
3419 r#disambiguating_description: r#disambiguating_description_property
3420 .unwrap_or_default(),
3421 r#identifier: r#identifier_property.unwrap_or_default(),
3422 r#image: r#image_property.unwrap_or_default(),
3423 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
3424 r#name: r#name_property.unwrap_or_default(),
3425 r#potential_action: r#potential_action_property.unwrap_or_default(),
3426 r#same_as: r#same_as_property.unwrap_or_default(),
3427 r#subject_of: r#subject_of_property.unwrap_or_default(),
3428 r#url: r#url_property.unwrap_or_default(),
3429 })
3430 }
3431 }
3432 const FIELDS: &[&str] = &[
3433 "awayTeam",
3434 "competitor",
3435 "homeTeam",
3436 "sport",
3437 "about",
3438 "actor",
3439 "aggregateRating",
3440 "attendee",
3441 "attendees",
3442 "audience",
3443 "composer",
3444 "contributor",
3445 "director",
3446 "doorTime",
3447 "duration",
3448 "endDate",
3449 "eventAttendanceMode",
3450 "eventSchedule",
3451 "eventStatus",
3452 "funder",
3453 "funding",
3454 "inLanguage",
3455 "isAccessibleForFree",
3456 "keywords",
3457 "location",
3458 "maximumAttendeeCapacity",
3459 "maximumPhysicalAttendeeCapacity",
3460 "maximumVirtualAttendeeCapacity",
3461 "offers",
3462 "organizer",
3463 "performer",
3464 "performers",
3465 "previousStartDate",
3466 "recordedIn",
3467 "remainingAttendeeCapacity",
3468 "review",
3469 "sponsor",
3470 "startDate",
3471 "subEvent",
3472 "subEvents",
3473 "superEvent",
3474 "translator",
3475 "typicalAgeRange",
3476 "workFeatured",
3477 "workPerformed",
3478 "additionalType",
3479 "alternateName",
3480 "description",
3481 "disambiguatingDescription",
3482 "identifier",
3483 "image",
3484 "mainEntityOfPage",
3485 "name",
3486 "potentialAction",
3487 "sameAs",
3488 "subjectOf",
3489 "url",
3490 ];
3491 deserializer.deserialize_struct("SportsEvent", FIELDS, ClassVisitor)
3492 }
3493 }
3494}