schema_org_types/schemas/classes/
event.rs

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

schema_org_types/schemas/classes/
event.rs
