schema_org_types/schemas/classes/
reservation_package.rs

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

schema_org_types/schemas/classes/
reservation_package.rs
