schema_org_types/schemas/classes/
event_reservation.rs

1use super::*;
2/// <https://schema.org/EventReservation>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct EventReservation {
6	/// <https://schema.org/bookingAgent>
7	#[deprecated = "This schema is superseded by <https://schema.org/broker>."]
8	pub r#booking_agent: Vec<BookingAgentProperty>,
9	/// <https://schema.org/bookingTime>
10	pub r#booking_time: Vec<BookingTimeProperty>,
11	/// <https://schema.org/broker>
12	pub r#broker: Vec<BrokerProperty>,
13	/// <https://schema.org/modifiedTime>
14	pub r#modified_time: Vec<ModifiedTimeProperty>,
15	/// <https://schema.org/priceCurrency>
16	pub r#price_currency: Vec<PriceCurrencyProperty>,
17	/// <https://schema.org/programMembershipUsed>
18	pub r#program_membership_used: Vec<ProgramMembershipUsedProperty>,
19	/// <https://schema.org/provider>
20	pub r#provider: Vec<ProviderProperty>,
21	/// <https://schema.org/reservationFor>
22	pub r#reservation_for: Vec<ReservationForProperty>,
23	/// <https://schema.org/reservationId>
24	pub r#reservation_id: Vec<ReservationIdProperty>,
25	/// <https://schema.org/reservationStatus>
26	pub r#reservation_status: Vec<ReservationStatusProperty>,
27	/// <https://schema.org/reservedTicket>
28	pub r#reserved_ticket: Vec<ReservedTicketProperty>,
29	/// <https://schema.org/totalPrice>
30	pub r#total_price: Vec<TotalPriceProperty>,
31	/// <https://schema.org/underName>
32	pub r#under_name: Vec<UnderNameProperty>,
33	/// <https://schema.org/additionalType>
34	pub r#additional_type: Vec<AdditionalTypeProperty>,
35	/// <https://schema.org/alternateName>
36	pub r#alternate_name: Vec<AlternateNameProperty>,
37	/// <https://schema.org/description>
38	pub r#description: Vec<DescriptionProperty>,
39	/// <https://schema.org/disambiguatingDescription>
40	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
41	/// <https://schema.org/identifier>
42	pub r#identifier: Vec<IdentifierProperty>,
43	/// <https://schema.org/image>
44	pub r#image: Vec<ImageProperty>,
45	/// <https://schema.org/mainEntityOfPage>
46	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
47	/// <https://schema.org/name>
48	pub r#name: Vec<NameProperty>,
49	/// <https://schema.org/potentialAction>
50	pub r#potential_action: Vec<PotentialActionProperty>,
51	/// <https://schema.org/sameAs>
52	pub r#same_as: Vec<SameAsProperty>,
53	/// <https://schema.org/subjectOf>
54	pub r#subject_of: Vec<SubjectOfProperty>,
55	/// <https://schema.org/url>
56	pub r#url: Vec<UrlProperty>,
57}
58/// This trait is for properties from <https://schema.org/EventReservation>.
59pub trait EventReservationTrait {}
60impl EventReservationTrait for EventReservation {}
61impl ReservationTrait for EventReservation {
62	fn get_booking_agent(&self) -> &[BookingAgentProperty] {
63		self.r#booking_agent.as_slice()
64	}
65	fn take_booking_agent(&mut self) -> Vec<BookingAgentProperty> {
66		std::mem::take(&mut self.r#booking_agent)
67	}
68	fn get_booking_time(&self) -> &[BookingTimeProperty] {
69		self.r#booking_time.as_slice()
70	}
71	fn take_booking_time(&mut self) -> Vec<BookingTimeProperty> {
72		std::mem::take(&mut self.r#booking_time)
73	}
74	fn get_broker(&self) -> &[BrokerProperty] {
75		self.r#broker.as_slice()
76	}
77	fn take_broker(&mut self) -> Vec<BrokerProperty> {
78		std::mem::take(&mut self.r#broker)
79	}
80	fn get_modified_time(&self) -> &[ModifiedTimeProperty] {
81		self.r#modified_time.as_slice()
82	}
83	fn take_modified_time(&mut self) -> Vec<ModifiedTimeProperty> {
84		std::mem::take(&mut self.r#modified_time)
85	}
86	fn get_price_currency(&self) -> &[PriceCurrencyProperty] {
87		self.r#price_currency.as_slice()
88	}
89	fn take_price_currency(&mut self) -> Vec<PriceCurrencyProperty> {
90		std::mem::take(&mut self.r#price_currency)
91	}
92	fn get_program_membership_used(&self) -> &[ProgramMembershipUsedProperty] {
93		self.r#program_membership_used.as_slice()
94	}
95	fn take_program_membership_used(&mut self) -> Vec<ProgramMembershipUsedProperty> {
96		std::mem::take(&mut self.r#program_membership_used)
97	}
98	fn get_provider(&self) -> &[ProviderProperty] {
99		self.r#provider.as_slice()
100	}
101	fn take_provider(&mut self) -> Vec<ProviderProperty> {
102		std::mem::take(&mut self.r#provider)
103	}
104	fn get_reservation_for(&self) -> &[ReservationForProperty] {
105		self.r#reservation_for.as_slice()
106	}
107	fn take_reservation_for(&mut self) -> Vec<ReservationForProperty> {
108		std::mem::take(&mut self.r#reservation_for)
109	}
110	fn get_reservation_id(&self) -> &[ReservationIdProperty] {
111		self.r#reservation_id.as_slice()
112	}
113	fn take_reservation_id(&mut self) -> Vec<ReservationIdProperty> {
114		std::mem::take(&mut self.r#reservation_id)
115	}
116	fn get_reservation_status(&self) -> &[ReservationStatusProperty] {
117		self.r#reservation_status.as_slice()
118	}
119	fn take_reservation_status(&mut self) -> Vec<ReservationStatusProperty> {
120		std::mem::take(&mut self.r#reservation_status)
121	}
122	fn get_reserved_ticket(&self) -> &[ReservedTicketProperty] {
123		self.r#reserved_ticket.as_slice()
124	}
125	fn take_reserved_ticket(&mut self) -> Vec<ReservedTicketProperty> {
126		std::mem::take(&mut self.r#reserved_ticket)
127	}
128	fn get_total_price(&self) -> &[TotalPriceProperty] {
129		self.r#total_price.as_slice()
130	}
131	fn take_total_price(&mut self) -> Vec<TotalPriceProperty> {
132		std::mem::take(&mut self.r#total_price)
133	}
134	fn get_under_name(&self) -> &[UnderNameProperty] {
135		self.r#under_name.as_slice()
136	}
137	fn take_under_name(&mut self) -> Vec<UnderNameProperty> {
138		std::mem::take(&mut self.r#under_name)
139	}
140}
141impl ThingTrait for EventReservation {
142	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
143		self.r#additional_type.as_slice()
144	}
145	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
146		std::mem::take(&mut self.r#additional_type)
147	}
148	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
149		self.r#alternate_name.as_slice()
150	}
151	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
152		std::mem::take(&mut self.r#alternate_name)
153	}
154	fn get_description(&self) -> &[DescriptionProperty] {
155		self.r#description.as_slice()
156	}
157	fn take_description(&mut self) -> Vec<DescriptionProperty> {
158		std::mem::take(&mut self.r#description)
159	}
160	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
161		self.r#disambiguating_description.as_slice()
162	}
163	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
164		std::mem::take(&mut self.r#disambiguating_description)
165	}
166	fn get_identifier(&self) -> &[IdentifierProperty] {
167		self.r#identifier.as_slice()
168	}
169	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
170		std::mem::take(&mut self.r#identifier)
171	}
172	fn get_image(&self) -> &[ImageProperty] {
173		self.r#image.as_slice()
174	}
175	fn take_image(&mut self) -> Vec<ImageProperty> {
176		std::mem::take(&mut self.r#image)
177	}
178	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
179		self.r#main_entity_of_page.as_slice()
180	}
181	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
182		std::mem::take(&mut self.r#main_entity_of_page)
183	}
184	fn get_name(&self) -> &[NameProperty] {
185		self.r#name.as_slice()
186	}
187	fn take_name(&mut self) -> Vec<NameProperty> {
188		std::mem::take(&mut self.r#name)
189	}
190	fn get_potential_action(&self) -> &[PotentialActionProperty] {
191		self.r#potential_action.as_slice()
192	}
193	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
194		std::mem::take(&mut self.r#potential_action)
195	}
196	fn get_same_as(&self) -> &[SameAsProperty] {
197		self.r#same_as.as_slice()
198	}
199	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
200		std::mem::take(&mut self.r#same_as)
201	}
202	fn get_subject_of(&self) -> &[SubjectOfProperty] {
203		self.r#subject_of.as_slice()
204	}
205	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
206		std::mem::take(&mut self.r#subject_of)
207	}
208	fn get_url(&self) -> &[UrlProperty] {
209		self.r#url.as_slice()
210	}
211	fn take_url(&mut self) -> Vec<UrlProperty> {
212		std::mem::take(&mut self.r#url)
213	}
214}
215#[cfg(feature = "serde")]
216mod serde {
217	use std::{fmt, fmt::Formatter};
218
219	use ::serde::{
220		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
221	};
222
223	use super::*;
224	impl Serialize for EventReservation {
225		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
226		where
227			S: Serializer,
228		{
229			let len: usize = [
230				!Vec::is_empty(&self.r#booking_agent) as usize,
231				!Vec::is_empty(&self.r#booking_time) as usize,
232				!Vec::is_empty(&self.r#broker) as usize,
233				!Vec::is_empty(&self.r#modified_time) as usize,
234				!Vec::is_empty(&self.r#price_currency) as usize,
235				!Vec::is_empty(&self.r#program_membership_used) as usize,
236				!Vec::is_empty(&self.r#provider) as usize,
237				!Vec::is_empty(&self.r#reservation_for) as usize,
238				!Vec::is_empty(&self.r#reservation_id) as usize,
239				!Vec::is_empty(&self.r#reservation_status) as usize,
240				!Vec::is_empty(&self.r#reserved_ticket) as usize,
241				!Vec::is_empty(&self.r#total_price) as usize,
242				!Vec::is_empty(&self.r#under_name) as usize,
243				!Vec::is_empty(&self.r#additional_type) as usize,
244				!Vec::is_empty(&self.r#alternate_name) as usize,
245				!Vec::is_empty(&self.r#description) as usize,
246				!Vec::is_empty(&self.r#disambiguating_description) as usize,
247				!Vec::is_empty(&self.r#identifier) as usize,
248				!Vec::is_empty(&self.r#image) as usize,
249				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
250				!Vec::is_empty(&self.r#name) as usize,
251				!Vec::is_empty(&self.r#potential_action) as usize,
252				!Vec::is_empty(&self.r#same_as) as usize,
253				!Vec::is_empty(&self.r#subject_of) as usize,
254				!Vec::is_empty(&self.r#url) as usize,
255			]
256			.iter()
257			.sum();
258			let mut serialize_struct =
259				Serializer::serialize_struct(serializer, "EventReservation", len)?;
260			if !Vec::is_empty(&self.r#booking_agent) {
261				serialize_struct.serialize_field("bookingAgent", {
262					struct SerializeWith<'a>(&'a Vec<BookingAgentProperty>);
263					impl<'a> Serialize for SerializeWith<'a> {
264						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
265						where
266							S: Serializer,
267						{
268							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
269								self.0, serializer,
270							)
271						}
272					}
273					&SerializeWith(&self.r#booking_agent)
274				})?;
275			} else {
276				serialize_struct.skip_field("bookingAgent")?;
277			}
278			if !Vec::is_empty(&self.r#booking_time) {
279				serialize_struct.serialize_field("bookingTime", {
280					struct SerializeWith<'a>(&'a Vec<BookingTimeProperty>);
281					impl<'a> Serialize for SerializeWith<'a> {
282						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
283						where
284							S: Serializer,
285						{
286							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
287								self.0, serializer,
288							)
289						}
290					}
291					&SerializeWith(&self.r#booking_time)
292				})?;
293			} else {
294				serialize_struct.skip_field("bookingTime")?;
295			}
296			if !Vec::is_empty(&self.r#broker) {
297				serialize_struct.serialize_field("broker", {
298					struct SerializeWith<'a>(&'a Vec<BrokerProperty>);
299					impl<'a> Serialize for SerializeWith<'a> {
300						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
301						where
302							S: Serializer,
303						{
304							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
305								self.0, serializer,
306							)
307						}
308					}
309					&SerializeWith(&self.r#broker)
310				})?;
311			} else {
312				serialize_struct.skip_field("broker")?;
313			}
314			if !Vec::is_empty(&self.r#modified_time) {
315				serialize_struct.serialize_field("modifiedTime", {
316					struct SerializeWith<'a>(&'a Vec<ModifiedTimeProperty>);
317					impl<'a> Serialize for SerializeWith<'a> {
318						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
319						where
320							S: Serializer,
321						{
322							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
323								self.0, serializer,
324							)
325						}
326					}
327					&SerializeWith(&self.r#modified_time)
328				})?;
329			} else {
330				serialize_struct.skip_field("modifiedTime")?;
331			}
332			if !Vec::is_empty(&self.r#price_currency) {
333				serialize_struct.serialize_field("priceCurrency", {
334					struct SerializeWith<'a>(&'a Vec<PriceCurrencyProperty>);
335					impl<'a> Serialize for SerializeWith<'a> {
336						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
337						where
338							S: Serializer,
339						{
340							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
341								self.0, serializer,
342							)
343						}
344					}
345					&SerializeWith(&self.r#price_currency)
346				})?;
347			} else {
348				serialize_struct.skip_field("priceCurrency")?;
349			}
350			if !Vec::is_empty(&self.r#program_membership_used) {
351				serialize_struct.serialize_field("programMembershipUsed", {
352					struct SerializeWith<'a>(&'a Vec<ProgramMembershipUsedProperty>);
353					impl<'a> Serialize for SerializeWith<'a> {
354						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
355						where
356							S: Serializer,
357						{
358							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
359								self.0, serializer,
360							)
361						}
362					}
363					&SerializeWith(&self.r#program_membership_used)
364				})?;
365			} else {
366				serialize_struct.skip_field("programMembershipUsed")?;
367			}
368			if !Vec::is_empty(&self.r#provider) {
369				serialize_struct.serialize_field("provider", {
370					struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
371					impl<'a> Serialize for SerializeWith<'a> {
372						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
373						where
374							S: Serializer,
375						{
376							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
377								self.0, serializer,
378							)
379						}
380					}
381					&SerializeWith(&self.r#provider)
382				})?;
383			} else {
384				serialize_struct.skip_field("provider")?;
385			}
386			if !Vec::is_empty(&self.r#reservation_for) {
387				serialize_struct.serialize_field("reservationFor", {
388					struct SerializeWith<'a>(&'a Vec<ReservationForProperty>);
389					impl<'a> Serialize for SerializeWith<'a> {
390						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
391						where
392							S: Serializer,
393						{
394							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
395								self.0, serializer,
396							)
397						}
398					}
399					&SerializeWith(&self.r#reservation_for)
400				})?;
401			} else {
402				serialize_struct.skip_field("reservationFor")?;
403			}
404			if !Vec::is_empty(&self.r#reservation_id) {
405				serialize_struct.serialize_field("reservationId", {
406					struct SerializeWith<'a>(&'a Vec<ReservationIdProperty>);
407					impl<'a> Serialize for SerializeWith<'a> {
408						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
409						where
410							S: Serializer,
411						{
412							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
413								self.0, serializer,
414							)
415						}
416					}
417					&SerializeWith(&self.r#reservation_id)
418				})?;
419			} else {
420				serialize_struct.skip_field("reservationId")?;
421			}
422			if !Vec::is_empty(&self.r#reservation_status) {
423				serialize_struct.serialize_field("reservationStatus", {
424					struct SerializeWith<'a>(&'a Vec<ReservationStatusProperty>);
425					impl<'a> Serialize for SerializeWith<'a> {
426						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
427						where
428							S: Serializer,
429						{
430							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
431								self.0, serializer,
432							)
433						}
434					}
435					&SerializeWith(&self.r#reservation_status)
436				})?;
437			} else {
438				serialize_struct.skip_field("reservationStatus")?;
439			}
440			if !Vec::is_empty(&self.r#reserved_ticket) {
441				serialize_struct.serialize_field("reservedTicket", {
442					struct SerializeWith<'a>(&'a Vec<ReservedTicketProperty>);
443					impl<'a> Serialize for SerializeWith<'a> {
444						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
445						where
446							S: Serializer,
447						{
448							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
449								self.0, serializer,
450							)
451						}
452					}
453					&SerializeWith(&self.r#reserved_ticket)
454				})?;
455			} else {
456				serialize_struct.skip_field("reservedTicket")?;
457			}
458			if !Vec::is_empty(&self.r#total_price) {
459				serialize_struct.serialize_field("totalPrice", {
460					struct SerializeWith<'a>(&'a Vec<TotalPriceProperty>);
461					impl<'a> Serialize for SerializeWith<'a> {
462						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
463						where
464							S: Serializer,
465						{
466							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
467								self.0, serializer,
468							)
469						}
470					}
471					&SerializeWith(&self.r#total_price)
472				})?;
473			} else {
474				serialize_struct.skip_field("totalPrice")?;
475			}
476			if !Vec::is_empty(&self.r#under_name) {
477				serialize_struct.serialize_field("underName", {
478					struct SerializeWith<'a>(&'a Vec<UnderNameProperty>);
479					impl<'a> Serialize for SerializeWith<'a> {
480						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
481						where
482							S: Serializer,
483						{
484							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
485								self.0, serializer,
486							)
487						}
488					}
489					&SerializeWith(&self.r#under_name)
490				})?;
491			} else {
492				serialize_struct.skip_field("underName")?;
493			}
494			if !Vec::is_empty(&self.r#additional_type) {
495				serialize_struct.serialize_field("additionalType", {
496					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
497					impl<'a> Serialize for SerializeWith<'a> {
498						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
499						where
500							S: Serializer,
501						{
502							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
503								self.0, serializer,
504							)
505						}
506					}
507					&SerializeWith(&self.r#additional_type)
508				})?;
509			} else {
510				serialize_struct.skip_field("additionalType")?;
511			}
512			if !Vec::is_empty(&self.r#alternate_name) {
513				serialize_struct.serialize_field("alternateName", {
514					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
515					impl<'a> Serialize for SerializeWith<'a> {
516						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
517						where
518							S: Serializer,
519						{
520							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
521								self.0, serializer,
522							)
523						}
524					}
525					&SerializeWith(&self.r#alternate_name)
526				})?;
527			} else {
528				serialize_struct.skip_field("alternateName")?;
529			}
530			if !Vec::is_empty(&self.r#description) {
531				serialize_struct.serialize_field("description", {
532					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
533					impl<'a> Serialize for SerializeWith<'a> {
534						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
535						where
536							S: Serializer,
537						{
538							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
539								self.0, serializer,
540							)
541						}
542					}
543					&SerializeWith(&self.r#description)
544				})?;
545			} else {
546				serialize_struct.skip_field("description")?;
547			}
548			if !Vec::is_empty(&self.r#disambiguating_description) {
549				serialize_struct.serialize_field("disambiguatingDescription", {
550					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
551					impl<'a> Serialize for SerializeWith<'a> {
552						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
553						where
554							S: Serializer,
555						{
556							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
557								self.0, serializer,
558							)
559						}
560					}
561					&SerializeWith(&self.r#disambiguating_description)
562				})?;
563			} else {
564				serialize_struct.skip_field("disambiguatingDescription")?;
565			}
566			if !Vec::is_empty(&self.r#identifier) {
567				serialize_struct.serialize_field("identifier", {
568					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
569					impl<'a> Serialize for SerializeWith<'a> {
570						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
571						where
572							S: Serializer,
573						{
574							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
575								self.0, serializer,
576							)
577						}
578					}
579					&SerializeWith(&self.r#identifier)
580				})?;
581			} else {
582				serialize_struct.skip_field("identifier")?;
583			}
584			if !Vec::is_empty(&self.r#image) {
585				serialize_struct.serialize_field("image", {
586					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
587					impl<'a> Serialize for SerializeWith<'a> {
588						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
589						where
590							S: Serializer,
591						{
592							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
593								self.0, serializer,
594							)
595						}
596					}
597					&SerializeWith(&self.r#image)
598				})?;
599			} else {
600				serialize_struct.skip_field("image")?;
601			}
602			if !Vec::is_empty(&self.r#main_entity_of_page) {
603				serialize_struct.serialize_field("mainEntityOfPage", {
604					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
605					impl<'a> Serialize for SerializeWith<'a> {
606						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
607						where
608							S: Serializer,
609						{
610							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
611								self.0, serializer,
612							)
613						}
614					}
615					&SerializeWith(&self.r#main_entity_of_page)
616				})?;
617			} else {
618				serialize_struct.skip_field("mainEntityOfPage")?;
619			}
620			if !Vec::is_empty(&self.r#name) {
621				serialize_struct.serialize_field("name", {
622					struct SerializeWith<'a>(&'a Vec<NameProperty>);
623					impl<'a> Serialize for SerializeWith<'a> {
624						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
625						where
626							S: Serializer,
627						{
628							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
629								self.0, serializer,
630							)
631						}
632					}
633					&SerializeWith(&self.r#name)
634				})?;
635			} else {
636				serialize_struct.skip_field("name")?;
637			}
638			if !Vec::is_empty(&self.r#potential_action) {
639				serialize_struct.serialize_field("potentialAction", {
640					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
641					impl<'a> Serialize for SerializeWith<'a> {
642						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
643						where
644							S: Serializer,
645						{
646							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
647								self.0, serializer,
648							)
649						}
650					}
651					&SerializeWith(&self.r#potential_action)
652				})?;
653			} else {
654				serialize_struct.skip_field("potentialAction")?;
655			}
656			if !Vec::is_empty(&self.r#same_as) {
657				serialize_struct.serialize_field("sameAs", {
658					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
659					impl<'a> Serialize for SerializeWith<'a> {
660						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
661						where
662							S: Serializer,
663						{
664							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
665								self.0, serializer,
666							)
667						}
668					}
669					&SerializeWith(&self.r#same_as)
670				})?;
671			} else {
672				serialize_struct.skip_field("sameAs")?;
673			}
674			if !Vec::is_empty(&self.r#subject_of) {
675				serialize_struct.serialize_field("subjectOf", {
676					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
677					impl<'a> Serialize for SerializeWith<'a> {
678						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
679						where
680							S: Serializer,
681						{
682							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
683								self.0, serializer,
684							)
685						}
686					}
687					&SerializeWith(&self.r#subject_of)
688				})?;
689			} else {
690				serialize_struct.skip_field("subjectOf")?;
691			}
692			if !Vec::is_empty(&self.r#url) {
693				serialize_struct.serialize_field("url", {
694					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
695					impl<'a> Serialize for SerializeWith<'a> {
696						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
697						where
698							S: Serializer,
699						{
700							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
701								self.0, serializer,
702							)
703						}
704					}
705					&SerializeWith(&self.r#url)
706				})?;
707			} else {
708				serialize_struct.skip_field("url")?;
709			}
710			serialize_struct.end()
711		}
712	}
713	impl<'de> Deserialize<'de> for EventReservation {
714		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
715		where
716			D: Deserializer<'de>,
717		{
718			enum Field {
719				BookingAgent,
720				BookingTime,
721				Broker,
722				ModifiedTime,
723				PriceCurrency,
724				ProgramMembershipUsed,
725				Provider,
726				ReservationFor,
727				ReservationId,
728				ReservationStatus,
729				ReservedTicket,
730				TotalPrice,
731				UnderName,
732				AdditionalType,
733				AlternateName,
734				Description,
735				DisambiguatingDescription,
736				Identifier,
737				Image,
738				MainEntityOfPage,
739				Name,
740				PotentialAction,
741				SameAs,
742				SubjectOf,
743				Url,
744				Ignore,
745			}
746			struct FieldVisitor;
747			impl<'de> Visitor<'de> for FieldVisitor {
748				type Value = Field;
749				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
750					formatter.write_str("field identifier")
751				}
752				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
753				where
754					E: de::Error,
755				{
756					match value {
757						"bookingAgent" => Ok(Field::BookingAgent),
758						"bookingTime" => Ok(Field::BookingTime),
759						"broker" => Ok(Field::Broker),
760						"modifiedTime" => Ok(Field::ModifiedTime),
761						"priceCurrency" => Ok(Field::PriceCurrency),
762						"programMembershipUsed" => Ok(Field::ProgramMembershipUsed),
763						"provider" => Ok(Field::Provider),
764						"reservationFor" => Ok(Field::ReservationFor),
765						"reservationId" => Ok(Field::ReservationId),
766						"reservationStatus" => Ok(Field::ReservationStatus),
767						"reservedTicket" => Ok(Field::ReservedTicket),
768						"totalPrice" => Ok(Field::TotalPrice),
769						"underName" => Ok(Field::UnderName),
770						"additionalType" => Ok(Field::AdditionalType),
771						"alternateName" => Ok(Field::AlternateName),
772						"description" => Ok(Field::Description),
773						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
774						"identifier" => Ok(Field::Identifier),
775						"image" => Ok(Field::Image),
776						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
777						"name" => Ok(Field::Name),
778						"potentialAction" => Ok(Field::PotentialAction),
779						"sameAs" => Ok(Field::SameAs),
780						"subjectOf" => Ok(Field::SubjectOf),
781						"url" => Ok(Field::Url),
782						"id" | "type" => Ok(Field::Ignore),
783						_ => Err(de::Error::unknown_field(value, FIELDS)),
784					}
785				}
786				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
787				where
788					E: de::Error,
789				{
790					match value {
791						b"bookingAgent" => Ok(Field::BookingAgent),
792						b"bookingTime" => Ok(Field::BookingTime),
793						b"broker" => Ok(Field::Broker),
794						b"modifiedTime" => Ok(Field::ModifiedTime),
795						b"priceCurrency" => Ok(Field::PriceCurrency),
796						b"programMembershipUsed" => Ok(Field::ProgramMembershipUsed),
797						b"provider" => Ok(Field::Provider),
798						b"reservationFor" => Ok(Field::ReservationFor),
799						b"reservationId" => Ok(Field::ReservationId),
800						b"reservationStatus" => Ok(Field::ReservationStatus),
801						b"reservedTicket" => Ok(Field::ReservedTicket),
802						b"totalPrice" => Ok(Field::TotalPrice),
803						b"underName" => Ok(Field::UnderName),
804						b"additionalType" => Ok(Field::AdditionalType),
805						b"alternateName" => Ok(Field::AlternateName),
806						b"description" => Ok(Field::Description),
807						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
808						b"identifier" => Ok(Field::Identifier),
809						b"image" => Ok(Field::Image),
810						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
811						b"name" => Ok(Field::Name),
812						b"potentialAction" => Ok(Field::PotentialAction),
813						b"sameAs" => Ok(Field::SameAs),
814						b"subjectOf" => Ok(Field::SubjectOf),
815						b"url" => Ok(Field::Url),
816						b"id" | b"type" => Ok(Field::Ignore),
817						_ => {
818							let value = &String::from_utf8_lossy(value);
819							Err(de::Error::unknown_field(value, FIELDS))
820						}
821					}
822				}
823			}
824			impl<'de> Deserialize<'de> for Field {
825				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
826				where
827					D: Deserializer<'de>,
828				{
829					deserializer.deserialize_identifier(FieldVisitor)
830				}
831			}
832			struct ClassVisitor;
833			impl<'de> Visitor<'de> for ClassVisitor {
834				type Value = EventReservation;
835				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
836					formatter.write_str("schema.org schema EventReservation")
837				}
838				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
839				where
840					A: de::MapAccess<'de>,
841				{
842					let mut r#booking_agent_property = None;
843					let mut r#booking_time_property = None;
844					let mut r#broker_property = None;
845					let mut r#modified_time_property = None;
846					let mut r#price_currency_property = None;
847					let mut r#program_membership_used_property = None;
848					let mut r#provider_property = None;
849					let mut r#reservation_for_property = None;
850					let mut r#reservation_id_property = None;
851					let mut r#reservation_status_property = None;
852					let mut r#reserved_ticket_property = None;
853					let mut r#total_price_property = None;
854					let mut r#under_name_property = None;
855					let mut r#additional_type_property = None;
856					let mut r#alternate_name_property = None;
857					let mut r#description_property = None;
858					let mut r#disambiguating_description_property = None;
859					let mut r#identifier_property = None;
860					let mut r#image_property = None;
861					let mut r#main_entity_of_page_property = None;
862					let mut r#name_property = None;
863					let mut r#potential_action_property = None;
864					let mut r#same_as_property = None;
865					let mut r#subject_of_property = None;
866					let mut r#url_property = None;
867					while let Some(key) = map.next_key::<Field>()? {
868						match key {
869							Field::BookingAgent => {
870								if r#booking_agent_property.is_some() {
871									return Err(<A::Error as de::Error>::duplicate_field(
872										"bookingAgent",
873									));
874								}
875								r#booking_agent_property = Some({
876									struct DeserializeWith(Vec<BookingAgentProperty>);
877									impl<'de> Deserialize<'de> for DeserializeWith {
878										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
879										where
880											D: Deserializer<'de>,
881										{
882											Ok(DeserializeWith(serde_with::As::<
883												serde_with::OneOrMany<serde_with::Same>,
884											>::deserialize(deserializer)?))
885										}
886									}
887									match map.next_value::<DeserializeWith>() {
888										Ok(deserialize_with) => deserialize_with.0,
889										Err(err) => {
890											return Err(err);
891										}
892									}
893								});
894							}
895							Field::BookingTime => {
896								if r#booking_time_property.is_some() {
897									return Err(<A::Error as de::Error>::duplicate_field(
898										"bookingTime",
899									));
900								}
901								r#booking_time_property = Some({
902									struct DeserializeWith(Vec<BookingTimeProperty>);
903									impl<'de> Deserialize<'de> for DeserializeWith {
904										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
905										where
906											D: Deserializer<'de>,
907										{
908											Ok(DeserializeWith(serde_with::As::<
909												serde_with::OneOrMany<serde_with::Same>,
910											>::deserialize(deserializer)?))
911										}
912									}
913									match map.next_value::<DeserializeWith>() {
914										Ok(deserialize_with) => deserialize_with.0,
915										Err(err) => {
916											return Err(err);
917										}
918									}
919								});
920							}
921							Field::Broker => {
922								if r#broker_property.is_some() {
923									return Err(<A::Error as de::Error>::duplicate_field("broker"));
924								}
925								r#broker_property = Some({
926									struct DeserializeWith(Vec<BrokerProperty>);
927									impl<'de> Deserialize<'de> for DeserializeWith {
928										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
929										where
930											D: Deserializer<'de>,
931										{
932											Ok(DeserializeWith(serde_with::As::<
933												serde_with::OneOrMany<serde_with::Same>,
934											>::deserialize(deserializer)?))
935										}
936									}
937									match map.next_value::<DeserializeWith>() {
938										Ok(deserialize_with) => deserialize_with.0,
939										Err(err) => {
940											return Err(err);
941										}
942									}
943								});
944							}
945							Field::ModifiedTime => {
946								if r#modified_time_property.is_some() {
947									return Err(<A::Error as de::Error>::duplicate_field(
948										"modifiedTime",
949									));
950								}
951								r#modified_time_property = Some({
952									struct DeserializeWith(Vec<ModifiedTimeProperty>);
953									impl<'de> Deserialize<'de> for DeserializeWith {
954										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
955										where
956											D: Deserializer<'de>,
957										{
958											Ok(DeserializeWith(serde_with::As::<
959												serde_with::OneOrMany<serde_with::Same>,
960											>::deserialize(deserializer)?))
961										}
962									}
963									match map.next_value::<DeserializeWith>() {
964										Ok(deserialize_with) => deserialize_with.0,
965										Err(err) => {
966											return Err(err);
967										}
968									}
969								});
970							}
971							Field::PriceCurrency => {
972								if r#price_currency_property.is_some() {
973									return Err(<A::Error as de::Error>::duplicate_field(
974										"priceCurrency",
975									));
976								}
977								r#price_currency_property = Some({
978									struct DeserializeWith(Vec<PriceCurrencyProperty>);
979									impl<'de> Deserialize<'de> for DeserializeWith {
980										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
981										where
982											D: Deserializer<'de>,
983										{
984											Ok(DeserializeWith(serde_with::As::<
985												serde_with::OneOrMany<serde_with::Same>,
986											>::deserialize(deserializer)?))
987										}
988									}
989									match map.next_value::<DeserializeWith>() {
990										Ok(deserialize_with) => deserialize_with.0,
991										Err(err) => {
992											return Err(err);
993										}
994									}
995								});
996							}
997							Field::ProgramMembershipUsed => {
998								if r#program_membership_used_property.is_some() {
999									return Err(<A::Error as de::Error>::duplicate_field(
1000										"programMembershipUsed",
1001									));
1002								}
1003								r#program_membership_used_property = Some({
1004									struct DeserializeWith(Vec<ProgramMembershipUsedProperty>);
1005									impl<'de> Deserialize<'de> for DeserializeWith {
1006										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1007										where
1008											D: Deserializer<'de>,
1009										{
1010											Ok(DeserializeWith(serde_with::As::<
1011												serde_with::OneOrMany<serde_with::Same>,
1012											>::deserialize(deserializer)?))
1013										}
1014									}
1015									match map.next_value::<DeserializeWith>() {
1016										Ok(deserialize_with) => deserialize_with.0,
1017										Err(err) => {
1018											return Err(err);
1019										}
1020									}
1021								});
1022							}
1023							Field::Provider => {
1024								if r#provider_property.is_some() {
1025									return Err(<A::Error as de::Error>::duplicate_field(
1026										"provider",
1027									));
1028								}
1029								r#provider_property = Some({
1030									struct DeserializeWith(Vec<ProviderProperty>);
1031									impl<'de> Deserialize<'de> for DeserializeWith {
1032										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1033										where
1034											D: Deserializer<'de>,
1035										{
1036											Ok(DeserializeWith(serde_with::As::<
1037												serde_with::OneOrMany<serde_with::Same>,
1038											>::deserialize(deserializer)?))
1039										}
1040									}
1041									match map.next_value::<DeserializeWith>() {
1042										Ok(deserialize_with) => deserialize_with.0,
1043										Err(err) => {
1044											return Err(err);
1045										}
1046									}
1047								});
1048							}
1049							Field::ReservationFor => {
1050								if r#reservation_for_property.is_some() {
1051									return Err(<A::Error as de::Error>::duplicate_field(
1052										"reservationFor",
1053									));
1054								}
1055								r#reservation_for_property = Some({
1056									struct DeserializeWith(Vec<ReservationForProperty>);
1057									impl<'de> Deserialize<'de> for DeserializeWith {
1058										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1059										where
1060											D: Deserializer<'de>,
1061										{
1062											Ok(DeserializeWith(serde_with::As::<
1063												serde_with::OneOrMany<serde_with::Same>,
1064											>::deserialize(deserializer)?))
1065										}
1066									}
1067									match map.next_value::<DeserializeWith>() {
1068										Ok(deserialize_with) => deserialize_with.0,
1069										Err(err) => {
1070											return Err(err);
1071										}
1072									}
1073								});
1074							}
1075							Field::ReservationId => {
1076								if r#reservation_id_property.is_some() {
1077									return Err(<A::Error as de::Error>::duplicate_field(
1078										"reservationId",
1079									));
1080								}
1081								r#reservation_id_property = Some({
1082									struct DeserializeWith(Vec<ReservationIdProperty>);
1083									impl<'de> Deserialize<'de> for DeserializeWith {
1084										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1085										where
1086											D: Deserializer<'de>,
1087										{
1088											Ok(DeserializeWith(serde_with::As::<
1089												serde_with::OneOrMany<serde_with::Same>,
1090											>::deserialize(deserializer)?))
1091										}
1092									}
1093									match map.next_value::<DeserializeWith>() {
1094										Ok(deserialize_with) => deserialize_with.0,
1095										Err(err) => {
1096											return Err(err);
1097										}
1098									}
1099								});
1100							}
1101							Field::ReservationStatus => {
1102								if r#reservation_status_property.is_some() {
1103									return Err(<A::Error as de::Error>::duplicate_field(
1104										"reservationStatus",
1105									));
1106								}
1107								r#reservation_status_property = Some({
1108									struct DeserializeWith(Vec<ReservationStatusProperty>);
1109									impl<'de> Deserialize<'de> for DeserializeWith {
1110										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1111										where
1112											D: Deserializer<'de>,
1113										{
1114											Ok(DeserializeWith(serde_with::As::<
1115												serde_with::OneOrMany<serde_with::Same>,
1116											>::deserialize(deserializer)?))
1117										}
1118									}
1119									match map.next_value::<DeserializeWith>() {
1120										Ok(deserialize_with) => deserialize_with.0,
1121										Err(err) => {
1122											return Err(err);
1123										}
1124									}
1125								});
1126							}
1127							Field::ReservedTicket => {
1128								if r#reserved_ticket_property.is_some() {
1129									return Err(<A::Error as de::Error>::duplicate_field(
1130										"reservedTicket",
1131									));
1132								}
1133								r#reserved_ticket_property = Some({
1134									struct DeserializeWith(Vec<ReservedTicketProperty>);
1135									impl<'de> Deserialize<'de> for DeserializeWith {
1136										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1137										where
1138											D: Deserializer<'de>,
1139										{
1140											Ok(DeserializeWith(serde_with::As::<
1141												serde_with::OneOrMany<serde_with::Same>,
1142											>::deserialize(deserializer)?))
1143										}
1144									}
1145									match map.next_value::<DeserializeWith>() {
1146										Ok(deserialize_with) => deserialize_with.0,
1147										Err(err) => {
1148											return Err(err);
1149										}
1150									}
1151								});
1152							}
1153							Field::TotalPrice => {
1154								if r#total_price_property.is_some() {
1155									return Err(<A::Error as de::Error>::duplicate_field(
1156										"totalPrice",
1157									));
1158								}
1159								r#total_price_property = Some({
1160									struct DeserializeWith(Vec<TotalPriceProperty>);
1161									impl<'de> Deserialize<'de> for DeserializeWith {
1162										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1163										where
1164											D: Deserializer<'de>,
1165										{
1166											Ok(DeserializeWith(serde_with::As::<
1167												serde_with::OneOrMany<serde_with::Same>,
1168											>::deserialize(deserializer)?))
1169										}
1170									}
1171									match map.next_value::<DeserializeWith>() {
1172										Ok(deserialize_with) => deserialize_with.0,
1173										Err(err) => {
1174											return Err(err);
1175										}
1176									}
1177								});
1178							}
1179							Field::UnderName => {
1180								if r#under_name_property.is_some() {
1181									return Err(<A::Error as de::Error>::duplicate_field(
1182										"underName",
1183									));
1184								}
1185								r#under_name_property = Some({
1186									struct DeserializeWith(Vec<UnderNameProperty>);
1187									impl<'de> Deserialize<'de> for DeserializeWith {
1188										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1189										where
1190											D: Deserializer<'de>,
1191										{
1192											Ok(DeserializeWith(serde_with::As::<
1193												serde_with::OneOrMany<serde_with::Same>,
1194											>::deserialize(deserializer)?))
1195										}
1196									}
1197									match map.next_value::<DeserializeWith>() {
1198										Ok(deserialize_with) => deserialize_with.0,
1199										Err(err) => {
1200											return Err(err);
1201										}
1202									}
1203								});
1204							}
1205							Field::AdditionalType => {
1206								if r#additional_type_property.is_some() {
1207									return Err(<A::Error as de::Error>::duplicate_field(
1208										"additionalType",
1209									));
1210								}
1211								r#additional_type_property = Some({
1212									struct DeserializeWith(Vec<AdditionalTypeProperty>);
1213									impl<'de> Deserialize<'de> for DeserializeWith {
1214										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1215										where
1216											D: Deserializer<'de>,
1217										{
1218											Ok(DeserializeWith(serde_with::As::<
1219												serde_with::OneOrMany<serde_with::Same>,
1220											>::deserialize(deserializer)?))
1221										}
1222									}
1223									match map.next_value::<DeserializeWith>() {
1224										Ok(deserialize_with) => deserialize_with.0,
1225										Err(err) => {
1226											return Err(err);
1227										}
1228									}
1229								});
1230							}
1231							Field::AlternateName => {
1232								if r#alternate_name_property.is_some() {
1233									return Err(<A::Error as de::Error>::duplicate_field(
1234										"alternateName",
1235									));
1236								}
1237								r#alternate_name_property = Some({
1238									struct DeserializeWith(Vec<AlternateNameProperty>);
1239									impl<'de> Deserialize<'de> for DeserializeWith {
1240										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1241										where
1242											D: Deserializer<'de>,
1243										{
1244											Ok(DeserializeWith(serde_with::As::<
1245												serde_with::OneOrMany<serde_with::Same>,
1246											>::deserialize(deserializer)?))
1247										}
1248									}
1249									match map.next_value::<DeserializeWith>() {
1250										Ok(deserialize_with) => deserialize_with.0,
1251										Err(err) => {
1252											return Err(err);
1253										}
1254									}
1255								});
1256							}
1257							Field::Description => {
1258								if r#description_property.is_some() {
1259									return Err(<A::Error as de::Error>::duplicate_field(
1260										"description",
1261									));
1262								}
1263								r#description_property = Some({
1264									struct DeserializeWith(Vec<DescriptionProperty>);
1265									impl<'de> Deserialize<'de> for DeserializeWith {
1266										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1267										where
1268											D: Deserializer<'de>,
1269										{
1270											Ok(DeserializeWith(serde_with::As::<
1271												serde_with::OneOrMany<serde_with::Same>,
1272											>::deserialize(deserializer)?))
1273										}
1274									}
1275									match map.next_value::<DeserializeWith>() {
1276										Ok(deserialize_with) => deserialize_with.0,
1277										Err(err) => {
1278											return Err(err);
1279										}
1280									}
1281								});
1282							}
1283							Field::DisambiguatingDescription => {
1284								if r#disambiguating_description_property.is_some() {
1285									return Err(<A::Error as de::Error>::duplicate_field(
1286										"disambiguatingDescription",
1287									));
1288								}
1289								r#disambiguating_description_property = Some({
1290									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1291									impl<'de> Deserialize<'de> for DeserializeWith {
1292										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1293										where
1294											D: Deserializer<'de>,
1295										{
1296											Ok(DeserializeWith(serde_with::As::<
1297												serde_with::OneOrMany<serde_with::Same>,
1298											>::deserialize(deserializer)?))
1299										}
1300									}
1301									match map.next_value::<DeserializeWith>() {
1302										Ok(deserialize_with) => deserialize_with.0,
1303										Err(err) => {
1304											return Err(err);
1305										}
1306									}
1307								});
1308							}
1309							Field::Identifier => {
1310								if r#identifier_property.is_some() {
1311									return Err(<A::Error as de::Error>::duplicate_field(
1312										"identifier",
1313									));
1314								}
1315								r#identifier_property = Some({
1316									struct DeserializeWith(Vec<IdentifierProperty>);
1317									impl<'de> Deserialize<'de> for DeserializeWith {
1318										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1319										where
1320											D: Deserializer<'de>,
1321										{
1322											Ok(DeserializeWith(serde_with::As::<
1323												serde_with::OneOrMany<serde_with::Same>,
1324											>::deserialize(deserializer)?))
1325										}
1326									}
1327									match map.next_value::<DeserializeWith>() {
1328										Ok(deserialize_with) => deserialize_with.0,
1329										Err(err) => {
1330											return Err(err);
1331										}
1332									}
1333								});
1334							}
1335							Field::Image => {
1336								if r#image_property.is_some() {
1337									return Err(<A::Error as de::Error>::duplicate_field("image"));
1338								}
1339								r#image_property = Some({
1340									struct DeserializeWith(Vec<ImageProperty>);
1341									impl<'de> Deserialize<'de> for DeserializeWith {
1342										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1343										where
1344											D: Deserializer<'de>,
1345										{
1346											Ok(DeserializeWith(serde_with::As::<
1347												serde_with::OneOrMany<serde_with::Same>,
1348											>::deserialize(deserializer)?))
1349										}
1350									}
1351									match map.next_value::<DeserializeWith>() {
1352										Ok(deserialize_with) => deserialize_with.0,
1353										Err(err) => {
1354											return Err(err);
1355										}
1356									}
1357								});
1358							}
1359							Field::MainEntityOfPage => {
1360								if r#main_entity_of_page_property.is_some() {
1361									return Err(<A::Error as de::Error>::duplicate_field(
1362										"mainEntityOfPage",
1363									));
1364								}
1365								r#main_entity_of_page_property = Some({
1366									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1367									impl<'de> Deserialize<'de> for DeserializeWith {
1368										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1369										where
1370											D: Deserializer<'de>,
1371										{
1372											Ok(DeserializeWith(serde_with::As::<
1373												serde_with::OneOrMany<serde_with::Same>,
1374											>::deserialize(deserializer)?))
1375										}
1376									}
1377									match map.next_value::<DeserializeWith>() {
1378										Ok(deserialize_with) => deserialize_with.0,
1379										Err(err) => {
1380											return Err(err);
1381										}
1382									}
1383								});
1384							}
1385							Field::Name => {
1386								if r#name_property.is_some() {
1387									return Err(<A::Error as de::Error>::duplicate_field("name"));
1388								}
1389								r#name_property = Some({
1390									struct DeserializeWith(Vec<NameProperty>);
1391									impl<'de> Deserialize<'de> for DeserializeWith {
1392										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1393										where
1394											D: Deserializer<'de>,
1395										{
1396											Ok(DeserializeWith(serde_with::As::<
1397												serde_with::OneOrMany<serde_with::Same>,
1398											>::deserialize(deserializer)?))
1399										}
1400									}
1401									match map.next_value::<DeserializeWith>() {
1402										Ok(deserialize_with) => deserialize_with.0,
1403										Err(err) => {
1404											return Err(err);
1405										}
1406									}
1407								});
1408							}
1409							Field::PotentialAction => {
1410								if r#potential_action_property.is_some() {
1411									return Err(<A::Error as de::Error>::duplicate_field(
1412										"potentialAction",
1413									));
1414								}
1415								r#potential_action_property = Some({
1416									struct DeserializeWith(Vec<PotentialActionProperty>);
1417									impl<'de> Deserialize<'de> for DeserializeWith {
1418										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1419										where
1420											D: Deserializer<'de>,
1421										{
1422											Ok(DeserializeWith(serde_with::As::<
1423												serde_with::OneOrMany<serde_with::Same>,
1424											>::deserialize(deserializer)?))
1425										}
1426									}
1427									match map.next_value::<DeserializeWith>() {
1428										Ok(deserialize_with) => deserialize_with.0,
1429										Err(err) => {
1430											return Err(err);
1431										}
1432									}
1433								});
1434							}
1435							Field::SameAs => {
1436								if r#same_as_property.is_some() {
1437									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1438								}
1439								r#same_as_property = Some({
1440									struct DeserializeWith(Vec<SameAsProperty>);
1441									impl<'de> Deserialize<'de> for DeserializeWith {
1442										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1443										where
1444											D: Deserializer<'de>,
1445										{
1446											Ok(DeserializeWith(serde_with::As::<
1447												serde_with::OneOrMany<serde_with::Same>,
1448											>::deserialize(deserializer)?))
1449										}
1450									}
1451									match map.next_value::<DeserializeWith>() {
1452										Ok(deserialize_with) => deserialize_with.0,
1453										Err(err) => {
1454											return Err(err);
1455										}
1456									}
1457								});
1458							}
1459							Field::SubjectOf => {
1460								if r#subject_of_property.is_some() {
1461									return Err(<A::Error as de::Error>::duplicate_field(
1462										"subjectOf",
1463									));
1464								}
1465								r#subject_of_property = Some({
1466									struct DeserializeWith(Vec<SubjectOfProperty>);
1467									impl<'de> Deserialize<'de> for DeserializeWith {
1468										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1469										where
1470											D: Deserializer<'de>,
1471										{
1472											Ok(DeserializeWith(serde_with::As::<
1473												serde_with::OneOrMany<serde_with::Same>,
1474											>::deserialize(deserializer)?))
1475										}
1476									}
1477									match map.next_value::<DeserializeWith>() {
1478										Ok(deserialize_with) => deserialize_with.0,
1479										Err(err) => {
1480											return Err(err);
1481										}
1482									}
1483								});
1484							}
1485							Field::Url => {
1486								if r#url_property.is_some() {
1487									return Err(<A::Error as de::Error>::duplicate_field("url"));
1488								}
1489								r#url_property = Some({
1490									struct DeserializeWith(Vec<UrlProperty>);
1491									impl<'de> Deserialize<'de> for DeserializeWith {
1492										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1493										where
1494											D: Deserializer<'de>,
1495										{
1496											Ok(DeserializeWith(serde_with::As::<
1497												serde_with::OneOrMany<serde_with::Same>,
1498											>::deserialize(deserializer)?))
1499										}
1500									}
1501									match map.next_value::<DeserializeWith>() {
1502										Ok(deserialize_with) => deserialize_with.0,
1503										Err(err) => {
1504											return Err(err);
1505										}
1506									}
1507								});
1508							}
1509							Field::Ignore => {
1510								let _ = map.next_value::<de::IgnoredAny>()?;
1511							}
1512						}
1513					}
1514					Ok(EventReservation {
1515						r#booking_agent: r#booking_agent_property.unwrap_or_default(),
1516						r#booking_time: r#booking_time_property.unwrap_or_default(),
1517						r#broker: r#broker_property.unwrap_or_default(),
1518						r#modified_time: r#modified_time_property.unwrap_or_default(),
1519						r#price_currency: r#price_currency_property.unwrap_or_default(),
1520						r#program_membership_used: r#program_membership_used_property
1521							.unwrap_or_default(),
1522						r#provider: r#provider_property.unwrap_or_default(),
1523						r#reservation_for: r#reservation_for_property.unwrap_or_default(),
1524						r#reservation_id: r#reservation_id_property.unwrap_or_default(),
1525						r#reservation_status: r#reservation_status_property.unwrap_or_default(),
1526						r#reserved_ticket: r#reserved_ticket_property.unwrap_or_default(),
1527						r#total_price: r#total_price_property.unwrap_or_default(),
1528						r#under_name: r#under_name_property.unwrap_or_default(),
1529						r#additional_type: r#additional_type_property.unwrap_or_default(),
1530						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1531						r#description: r#description_property.unwrap_or_default(),
1532						r#disambiguating_description: r#disambiguating_description_property
1533							.unwrap_or_default(),
1534						r#identifier: r#identifier_property.unwrap_or_default(),
1535						r#image: r#image_property.unwrap_or_default(),
1536						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1537						r#name: r#name_property.unwrap_or_default(),
1538						r#potential_action: r#potential_action_property.unwrap_or_default(),
1539						r#same_as: r#same_as_property.unwrap_or_default(),
1540						r#subject_of: r#subject_of_property.unwrap_or_default(),
1541						r#url: r#url_property.unwrap_or_default(),
1542					})
1543				}
1544			}
1545			const FIELDS: &[&str] = &[
1546				"bookingAgent",
1547				"bookingTime",
1548				"broker",
1549				"modifiedTime",
1550				"priceCurrency",
1551				"programMembershipUsed",
1552				"provider",
1553				"reservationFor",
1554				"reservationId",
1555				"reservationStatus",
1556				"reservedTicket",
1557				"totalPrice",
1558				"underName",
1559				"additionalType",
1560				"alternateName",
1561				"description",
1562				"disambiguatingDescription",
1563				"identifier",
1564				"image",
1565				"mainEntityOfPage",
1566				"name",
1567				"potentialAction",
1568				"sameAs",
1569				"subjectOf",
1570				"url",
1571			];
1572			deserializer.deserialize_struct("EventReservation", FIELDS, ClassVisitor)
1573		}
1574	}
1575}
schema_org_types/schemas/classes/event_reservation.rs

schema_org_types/schemas/classes/
event_reservation.rs
