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