schema_org_types/schemas/classes/
train_trip.rs

1use super::*;
2/// <https://schema.org/TrainTrip>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct TrainTrip {
6	/// <https://schema.org/arrivalPlatform>
7	pub r#arrival_platform: Vec<ArrivalPlatformProperty>,
8	/// <https://schema.org/arrivalStation>
9	pub r#arrival_station: Vec<ArrivalStationProperty>,
10	/// <https://schema.org/departurePlatform>
11	pub r#departure_platform: Vec<DeparturePlatformProperty>,
12	/// <https://schema.org/departureStation>
13	pub r#departure_station: Vec<DepartureStationProperty>,
14	/// <https://schema.org/trainName>
15	pub r#train_name: Vec<TrainNameProperty>,
16	/// <https://schema.org/trainNumber>
17	pub r#train_number: Vec<TrainNumberProperty>,
18	/// <https://schema.org/additionalType>
19	pub r#additional_type: Vec<AdditionalTypeProperty>,
20	/// <https://schema.org/alternateName>
21	pub r#alternate_name: Vec<AlternateNameProperty>,
22	/// <https://schema.org/description>
23	pub r#description: Vec<DescriptionProperty>,
24	/// <https://schema.org/disambiguatingDescription>
25	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
26	/// <https://schema.org/identifier>
27	pub r#identifier: Vec<IdentifierProperty>,
28	/// <https://schema.org/image>
29	pub r#image: Vec<ImageProperty>,
30	/// <https://schema.org/mainEntityOfPage>
31	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
32	/// <https://schema.org/name>
33	pub r#name: Vec<NameProperty>,
34	/// <https://schema.org/potentialAction>
35	pub r#potential_action: Vec<PotentialActionProperty>,
36	/// <https://schema.org/sameAs>
37	pub r#same_as: Vec<SameAsProperty>,
38	/// <https://schema.org/subjectOf>
39	pub r#subject_of: Vec<SubjectOfProperty>,
40	/// <https://schema.org/url>
41	pub r#url: Vec<UrlProperty>,
42	/// <https://schema.org/arrivalTime>
43	pub r#arrival_time: Vec<ArrivalTimeProperty>,
44	/// <https://schema.org/departureTime>
45	pub r#departure_time: Vec<DepartureTimeProperty>,
46	/// <https://schema.org/itinerary>
47	pub r#itinerary: Vec<ItineraryProperty>,
48	/// <https://schema.org/offers>
49	pub r#offers: Vec<OffersProperty>,
50	/// <https://schema.org/partOfTrip>
51	pub r#part_of_trip: Vec<PartOfTripProperty>,
52	/// <https://schema.org/provider>
53	pub r#provider: Vec<ProviderProperty>,
54	/// <https://schema.org/subTrip>
55	pub r#sub_trip: Vec<SubTripProperty>,
56	/// <https://schema.org/tripOrigin>
57	pub r#trip_origin: Vec<TripOriginProperty>,
58}
59/// This trait is for properties from <https://schema.org/TrainTrip>.
60pub trait TrainTripTrait {
61	/// Get <https://schema.org/arrivalPlatform> from [`Self`] as borrowed slice.
62	fn get_arrival_platform(&self) -> &[ArrivalPlatformProperty];
63	/// Take <https://schema.org/arrivalPlatform> from [`Self`] as owned vector.
64	fn take_arrival_platform(&mut self) -> Vec<ArrivalPlatformProperty>;
65	/// Get <https://schema.org/arrivalStation> from [`Self`] as borrowed slice.
66	fn get_arrival_station(&self) -> &[ArrivalStationProperty];
67	/// Take <https://schema.org/arrivalStation> from [`Self`] as owned vector.
68	fn take_arrival_station(&mut self) -> Vec<ArrivalStationProperty>;
69	/// Get <https://schema.org/departurePlatform> from [`Self`] as borrowed slice.
70	fn get_departure_platform(&self) -> &[DeparturePlatformProperty];
71	/// Take <https://schema.org/departurePlatform> from [`Self`] as owned vector.
72	fn take_departure_platform(&mut self) -> Vec<DeparturePlatformProperty>;
73	/// Get <https://schema.org/departureStation> from [`Self`] as borrowed slice.
74	fn get_departure_station(&self) -> &[DepartureStationProperty];
75	/// Take <https://schema.org/departureStation> from [`Self`] as owned vector.
76	fn take_departure_station(&mut self) -> Vec<DepartureStationProperty>;
77	/// Get <https://schema.org/trainName> from [`Self`] as borrowed slice.
78	fn get_train_name(&self) -> &[TrainNameProperty];
79	/// Take <https://schema.org/trainName> from [`Self`] as owned vector.
80	fn take_train_name(&mut self) -> Vec<TrainNameProperty>;
81	/// Get <https://schema.org/trainNumber> from [`Self`] as borrowed slice.
82	fn get_train_number(&self) -> &[TrainNumberProperty];
83	/// Take <https://schema.org/trainNumber> from [`Self`] as owned vector.
84	fn take_train_number(&mut self) -> Vec<TrainNumberProperty>;
85}
86impl TrainTripTrait for TrainTrip {
87	fn get_arrival_platform(&self) -> &[ArrivalPlatformProperty] {
88		self.r#arrival_platform.as_slice()
89	}
90	fn take_arrival_platform(&mut self) -> Vec<ArrivalPlatformProperty> {
91		std::mem::take(&mut self.r#arrival_platform)
92	}
93	fn get_arrival_station(&self) -> &[ArrivalStationProperty] {
94		self.r#arrival_station.as_slice()
95	}
96	fn take_arrival_station(&mut self) -> Vec<ArrivalStationProperty> {
97		std::mem::take(&mut self.r#arrival_station)
98	}
99	fn get_departure_platform(&self) -> &[DeparturePlatformProperty] {
100		self.r#departure_platform.as_slice()
101	}
102	fn take_departure_platform(&mut self) -> Vec<DeparturePlatformProperty> {
103		std::mem::take(&mut self.r#departure_platform)
104	}
105	fn get_departure_station(&self) -> &[DepartureStationProperty] {
106		self.r#departure_station.as_slice()
107	}
108	fn take_departure_station(&mut self) -> Vec<DepartureStationProperty> {
109		std::mem::take(&mut self.r#departure_station)
110	}
111	fn get_train_name(&self) -> &[TrainNameProperty] {
112		self.r#train_name.as_slice()
113	}
114	fn take_train_name(&mut self) -> Vec<TrainNameProperty> {
115		std::mem::take(&mut self.r#train_name)
116	}
117	fn get_train_number(&self) -> &[TrainNumberProperty] {
118		self.r#train_number.as_slice()
119	}
120	fn take_train_number(&mut self) -> Vec<TrainNumberProperty> {
121		std::mem::take(&mut self.r#train_number)
122	}
123}
124impl ThingTrait for TrainTrip {
125	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
126		self.r#additional_type.as_slice()
127	}
128	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
129		std::mem::take(&mut self.r#additional_type)
130	}
131	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
132		self.r#alternate_name.as_slice()
133	}
134	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
135		std::mem::take(&mut self.r#alternate_name)
136	}
137	fn get_description(&self) -> &[DescriptionProperty] {
138		self.r#description.as_slice()
139	}
140	fn take_description(&mut self) -> Vec<DescriptionProperty> {
141		std::mem::take(&mut self.r#description)
142	}
143	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
144		self.r#disambiguating_description.as_slice()
145	}
146	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
147		std::mem::take(&mut self.r#disambiguating_description)
148	}
149	fn get_identifier(&self) -> &[IdentifierProperty] {
150		self.r#identifier.as_slice()
151	}
152	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
153		std::mem::take(&mut self.r#identifier)
154	}
155	fn get_image(&self) -> &[ImageProperty] {
156		self.r#image.as_slice()
157	}
158	fn take_image(&mut self) -> Vec<ImageProperty> {
159		std::mem::take(&mut self.r#image)
160	}
161	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
162		self.r#main_entity_of_page.as_slice()
163	}
164	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
165		std::mem::take(&mut self.r#main_entity_of_page)
166	}
167	fn get_name(&self) -> &[NameProperty] {
168		self.r#name.as_slice()
169	}
170	fn take_name(&mut self) -> Vec<NameProperty> {
171		std::mem::take(&mut self.r#name)
172	}
173	fn get_potential_action(&self) -> &[PotentialActionProperty] {
174		self.r#potential_action.as_slice()
175	}
176	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
177		std::mem::take(&mut self.r#potential_action)
178	}
179	fn get_same_as(&self) -> &[SameAsProperty] {
180		self.r#same_as.as_slice()
181	}
182	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
183		std::mem::take(&mut self.r#same_as)
184	}
185	fn get_subject_of(&self) -> &[SubjectOfProperty] {
186		self.r#subject_of.as_slice()
187	}
188	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
189		std::mem::take(&mut self.r#subject_of)
190	}
191	fn get_url(&self) -> &[UrlProperty] {
192		self.r#url.as_slice()
193	}
194	fn take_url(&mut self) -> Vec<UrlProperty> {
195		std::mem::take(&mut self.r#url)
196	}
197}
198impl TripTrait for TrainTrip {
199	fn get_arrival_time(&self) -> &[ArrivalTimeProperty] {
200		self.r#arrival_time.as_slice()
201	}
202	fn take_arrival_time(&mut self) -> Vec<ArrivalTimeProperty> {
203		std::mem::take(&mut self.r#arrival_time)
204	}
205	fn get_departure_time(&self) -> &[DepartureTimeProperty] {
206		self.r#departure_time.as_slice()
207	}
208	fn take_departure_time(&mut self) -> Vec<DepartureTimeProperty> {
209		std::mem::take(&mut self.r#departure_time)
210	}
211	fn get_itinerary(&self) -> &[ItineraryProperty] {
212		self.r#itinerary.as_slice()
213	}
214	fn take_itinerary(&mut self) -> Vec<ItineraryProperty> {
215		std::mem::take(&mut self.r#itinerary)
216	}
217	fn get_offers(&self) -> &[OffersProperty] {
218		self.r#offers.as_slice()
219	}
220	fn take_offers(&mut self) -> Vec<OffersProperty> {
221		std::mem::take(&mut self.r#offers)
222	}
223	fn get_part_of_trip(&self) -> &[PartOfTripProperty] {
224		self.r#part_of_trip.as_slice()
225	}
226	fn take_part_of_trip(&mut self) -> Vec<PartOfTripProperty> {
227		std::mem::take(&mut self.r#part_of_trip)
228	}
229	fn get_provider(&self) -> &[ProviderProperty] {
230		self.r#provider.as_slice()
231	}
232	fn take_provider(&mut self) -> Vec<ProviderProperty> {
233		std::mem::take(&mut self.r#provider)
234	}
235	fn get_sub_trip(&self) -> &[SubTripProperty] {
236		self.r#sub_trip.as_slice()
237	}
238	fn take_sub_trip(&mut self) -> Vec<SubTripProperty> {
239		std::mem::take(&mut self.r#sub_trip)
240	}
241	fn get_trip_origin(&self) -> &[TripOriginProperty] {
242		self.r#trip_origin.as_slice()
243	}
244	fn take_trip_origin(&mut self) -> Vec<TripOriginProperty> {
245		std::mem::take(&mut self.r#trip_origin)
246	}
247}
248#[cfg(feature = "serde")]
249mod serde {
250	use std::{fmt, fmt::Formatter};
251
252	use ::serde::{
253		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
254	};
255
256	use super::*;
257	impl Serialize for TrainTrip {
258		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
259		where
260			S: Serializer,
261		{
262			let len: usize = [
263				!Vec::is_empty(&self.r#arrival_platform) as usize,
264				!Vec::is_empty(&self.r#arrival_station) as usize,
265				!Vec::is_empty(&self.r#departure_platform) as usize,
266				!Vec::is_empty(&self.r#departure_station) as usize,
267				!Vec::is_empty(&self.r#train_name) as usize,
268				!Vec::is_empty(&self.r#train_number) as usize,
269				!Vec::is_empty(&self.r#additional_type) as usize,
270				!Vec::is_empty(&self.r#alternate_name) as usize,
271				!Vec::is_empty(&self.r#description) as usize,
272				!Vec::is_empty(&self.r#disambiguating_description) as usize,
273				!Vec::is_empty(&self.r#identifier) as usize,
274				!Vec::is_empty(&self.r#image) as usize,
275				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
276				!Vec::is_empty(&self.r#name) as usize,
277				!Vec::is_empty(&self.r#potential_action) as usize,
278				!Vec::is_empty(&self.r#same_as) as usize,
279				!Vec::is_empty(&self.r#subject_of) as usize,
280				!Vec::is_empty(&self.r#url) as usize,
281				!Vec::is_empty(&self.r#arrival_time) as usize,
282				!Vec::is_empty(&self.r#departure_time) as usize,
283				!Vec::is_empty(&self.r#itinerary) as usize,
284				!Vec::is_empty(&self.r#offers) as usize,
285				!Vec::is_empty(&self.r#part_of_trip) as usize,
286				!Vec::is_empty(&self.r#provider) as usize,
287				!Vec::is_empty(&self.r#sub_trip) as usize,
288				!Vec::is_empty(&self.r#trip_origin) as usize,
289			]
290			.iter()
291			.sum();
292			let mut serialize_struct = Serializer::serialize_struct(serializer, "TrainTrip", len)?;
293			if !Vec::is_empty(&self.r#arrival_platform) {
294				serialize_struct.serialize_field("arrivalPlatform", {
295					struct SerializeWith<'a>(&'a Vec<ArrivalPlatformProperty>);
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#arrival_platform)
307				})?;
308			} else {
309				serialize_struct.skip_field("arrivalPlatform")?;
310			}
311			if !Vec::is_empty(&self.r#arrival_station) {
312				serialize_struct.serialize_field("arrivalStation", {
313					struct SerializeWith<'a>(&'a Vec<ArrivalStationProperty>);
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#arrival_station)
325				})?;
326			} else {
327				serialize_struct.skip_field("arrivalStation")?;
328			}
329			if !Vec::is_empty(&self.r#departure_platform) {
330				serialize_struct.serialize_field("departurePlatform", {
331					struct SerializeWith<'a>(&'a Vec<DeparturePlatformProperty>);
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#departure_platform)
343				})?;
344			} else {
345				serialize_struct.skip_field("departurePlatform")?;
346			}
347			if !Vec::is_empty(&self.r#departure_station) {
348				serialize_struct.serialize_field("departureStation", {
349					struct SerializeWith<'a>(&'a Vec<DepartureStationProperty>);
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#departure_station)
361				})?;
362			} else {
363				serialize_struct.skip_field("departureStation")?;
364			}
365			if !Vec::is_empty(&self.r#train_name) {
366				serialize_struct.serialize_field("trainName", {
367					struct SerializeWith<'a>(&'a Vec<TrainNameProperty>);
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#train_name)
379				})?;
380			} else {
381				serialize_struct.skip_field("trainName")?;
382			}
383			if !Vec::is_empty(&self.r#train_number) {
384				serialize_struct.serialize_field("trainNumber", {
385					struct SerializeWith<'a>(&'a Vec<TrainNumberProperty>);
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#train_number)
397				})?;
398			} else {
399				serialize_struct.skip_field("trainNumber")?;
400			}
401			if !Vec::is_empty(&self.r#additional_type) {
402				serialize_struct.serialize_field("additionalType", {
403					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
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#additional_type)
415				})?;
416			} else {
417				serialize_struct.skip_field("additionalType")?;
418			}
419			if !Vec::is_empty(&self.r#alternate_name) {
420				serialize_struct.serialize_field("alternateName", {
421					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
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#alternate_name)
433				})?;
434			} else {
435				serialize_struct.skip_field("alternateName")?;
436			}
437			if !Vec::is_empty(&self.r#description) {
438				serialize_struct.serialize_field("description", {
439					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
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#description)
451				})?;
452			} else {
453				serialize_struct.skip_field("description")?;
454			}
455			if !Vec::is_empty(&self.r#disambiguating_description) {
456				serialize_struct.serialize_field("disambiguatingDescription", {
457					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
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#disambiguating_description)
469				})?;
470			} else {
471				serialize_struct.skip_field("disambiguatingDescription")?;
472			}
473			if !Vec::is_empty(&self.r#identifier) {
474				serialize_struct.serialize_field("identifier", {
475					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
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#identifier)
487				})?;
488			} else {
489				serialize_struct.skip_field("identifier")?;
490			}
491			if !Vec::is_empty(&self.r#image) {
492				serialize_struct.serialize_field("image", {
493					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
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#image)
505				})?;
506			} else {
507				serialize_struct.skip_field("image")?;
508			}
509			if !Vec::is_empty(&self.r#main_entity_of_page) {
510				serialize_struct.serialize_field("mainEntityOfPage", {
511					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
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#main_entity_of_page)
523				})?;
524			} else {
525				serialize_struct.skip_field("mainEntityOfPage")?;
526			}
527			if !Vec::is_empty(&self.r#name) {
528				serialize_struct.serialize_field("name", {
529					struct SerializeWith<'a>(&'a Vec<NameProperty>);
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#name)
541				})?;
542			} else {
543				serialize_struct.skip_field("name")?;
544			}
545			if !Vec::is_empty(&self.r#potential_action) {
546				serialize_struct.serialize_field("potentialAction", {
547					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
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#potential_action)
559				})?;
560			} else {
561				serialize_struct.skip_field("potentialAction")?;
562			}
563			if !Vec::is_empty(&self.r#same_as) {
564				serialize_struct.serialize_field("sameAs", {
565					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
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#same_as)
577				})?;
578			} else {
579				serialize_struct.skip_field("sameAs")?;
580			}
581			if !Vec::is_empty(&self.r#subject_of) {
582				serialize_struct.serialize_field("subjectOf", {
583					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
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#subject_of)
595				})?;
596			} else {
597				serialize_struct.skip_field("subjectOf")?;
598			}
599			if !Vec::is_empty(&self.r#url) {
600				serialize_struct.serialize_field("url", {
601					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
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#url)
613				})?;
614			} else {
615				serialize_struct.skip_field("url")?;
616			}
617			if !Vec::is_empty(&self.r#arrival_time) {
618				serialize_struct.serialize_field("arrivalTime", {
619					struct SerializeWith<'a>(&'a Vec<ArrivalTimeProperty>);
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#arrival_time)
631				})?;
632			} else {
633				serialize_struct.skip_field("arrivalTime")?;
634			}
635			if !Vec::is_empty(&self.r#departure_time) {
636				serialize_struct.serialize_field("departureTime", {
637					struct SerializeWith<'a>(&'a Vec<DepartureTimeProperty>);
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#departure_time)
649				})?;
650			} else {
651				serialize_struct.skip_field("departureTime")?;
652			}
653			if !Vec::is_empty(&self.r#itinerary) {
654				serialize_struct.serialize_field("itinerary", {
655					struct SerializeWith<'a>(&'a Vec<ItineraryProperty>);
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#itinerary)
667				})?;
668			} else {
669				serialize_struct.skip_field("itinerary")?;
670			}
671			if !Vec::is_empty(&self.r#offers) {
672				serialize_struct.serialize_field("offers", {
673					struct SerializeWith<'a>(&'a Vec<OffersProperty>);
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#offers)
685				})?;
686			} else {
687				serialize_struct.skip_field("offers")?;
688			}
689			if !Vec::is_empty(&self.r#part_of_trip) {
690				serialize_struct.serialize_field("partOfTrip", {
691					struct SerializeWith<'a>(&'a Vec<PartOfTripProperty>);
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#part_of_trip)
703				})?;
704			} else {
705				serialize_struct.skip_field("partOfTrip")?;
706			}
707			if !Vec::is_empty(&self.r#provider) {
708				serialize_struct.serialize_field("provider", {
709					struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
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#provider)
721				})?;
722			} else {
723				serialize_struct.skip_field("provider")?;
724			}
725			if !Vec::is_empty(&self.r#sub_trip) {
726				serialize_struct.serialize_field("subTrip", {
727					struct SerializeWith<'a>(&'a Vec<SubTripProperty>);
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#sub_trip)
739				})?;
740			} else {
741				serialize_struct.skip_field("subTrip")?;
742			}
743			if !Vec::is_empty(&self.r#trip_origin) {
744				serialize_struct.serialize_field("tripOrigin", {
745					struct SerializeWith<'a>(&'a Vec<TripOriginProperty>);
746					impl<'a> Serialize for SerializeWith<'a> {
747						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
748						where
749							S: Serializer,
750						{
751							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
752								self.0, serializer,
753							)
754						}
755					}
756					&SerializeWith(&self.r#trip_origin)
757				})?;
758			} else {
759				serialize_struct.skip_field("tripOrigin")?;
760			}
761			serialize_struct.end()
762		}
763	}
764	impl<'de> Deserialize<'de> for TrainTrip {
765		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
766		where
767			D: Deserializer<'de>,
768		{
769			enum Field {
770				ArrivalPlatform,
771				ArrivalStation,
772				DeparturePlatform,
773				DepartureStation,
774				TrainName,
775				TrainNumber,
776				AdditionalType,
777				AlternateName,
778				Description,
779				DisambiguatingDescription,
780				Identifier,
781				Image,
782				MainEntityOfPage,
783				Name,
784				PotentialAction,
785				SameAs,
786				SubjectOf,
787				Url,
788				ArrivalTime,
789				DepartureTime,
790				Itinerary,
791				Offers,
792				PartOfTrip,
793				Provider,
794				SubTrip,
795				TripOrigin,
796				Ignore,
797			}
798			struct FieldVisitor;
799			impl<'de> Visitor<'de> for FieldVisitor {
800				type Value = Field;
801				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
802					formatter.write_str("field identifier")
803				}
804				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
805				where
806					E: de::Error,
807				{
808					match value {
809						"arrivalPlatform" => Ok(Field::ArrivalPlatform),
810						"arrivalStation" => Ok(Field::ArrivalStation),
811						"departurePlatform" => Ok(Field::DeparturePlatform),
812						"departureStation" => Ok(Field::DepartureStation),
813						"trainName" => Ok(Field::TrainName),
814						"trainNumber" => Ok(Field::TrainNumber),
815						"additionalType" => Ok(Field::AdditionalType),
816						"alternateName" => Ok(Field::AlternateName),
817						"description" => Ok(Field::Description),
818						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
819						"identifier" => Ok(Field::Identifier),
820						"image" => Ok(Field::Image),
821						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
822						"name" => Ok(Field::Name),
823						"potentialAction" => Ok(Field::PotentialAction),
824						"sameAs" => Ok(Field::SameAs),
825						"subjectOf" => Ok(Field::SubjectOf),
826						"url" => Ok(Field::Url),
827						"arrivalTime" => Ok(Field::ArrivalTime),
828						"departureTime" => Ok(Field::DepartureTime),
829						"itinerary" => Ok(Field::Itinerary),
830						"offers" => Ok(Field::Offers),
831						"partOfTrip" => Ok(Field::PartOfTrip),
832						"provider" => Ok(Field::Provider),
833						"subTrip" => Ok(Field::SubTrip),
834						"tripOrigin" => Ok(Field::TripOrigin),
835						"id" | "type" => Ok(Field::Ignore),
836						_ => Err(de::Error::unknown_field(value, FIELDS)),
837					}
838				}
839				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
840				where
841					E: de::Error,
842				{
843					match value {
844						b"arrivalPlatform" => Ok(Field::ArrivalPlatform),
845						b"arrivalStation" => Ok(Field::ArrivalStation),
846						b"departurePlatform" => Ok(Field::DeparturePlatform),
847						b"departureStation" => Ok(Field::DepartureStation),
848						b"trainName" => Ok(Field::TrainName),
849						b"trainNumber" => Ok(Field::TrainNumber),
850						b"additionalType" => Ok(Field::AdditionalType),
851						b"alternateName" => Ok(Field::AlternateName),
852						b"description" => Ok(Field::Description),
853						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
854						b"identifier" => Ok(Field::Identifier),
855						b"image" => Ok(Field::Image),
856						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
857						b"name" => Ok(Field::Name),
858						b"potentialAction" => Ok(Field::PotentialAction),
859						b"sameAs" => Ok(Field::SameAs),
860						b"subjectOf" => Ok(Field::SubjectOf),
861						b"url" => Ok(Field::Url),
862						b"arrivalTime" => Ok(Field::ArrivalTime),
863						b"departureTime" => Ok(Field::DepartureTime),
864						b"itinerary" => Ok(Field::Itinerary),
865						b"offers" => Ok(Field::Offers),
866						b"partOfTrip" => Ok(Field::PartOfTrip),
867						b"provider" => Ok(Field::Provider),
868						b"subTrip" => Ok(Field::SubTrip),
869						b"tripOrigin" => Ok(Field::TripOrigin),
870						b"id" | b"type" => Ok(Field::Ignore),
871						_ => {
872							let value = &String::from_utf8_lossy(value);
873							Err(de::Error::unknown_field(value, FIELDS))
874						}
875					}
876				}
877			}
878			impl<'de> Deserialize<'de> for Field {
879				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
880				where
881					D: Deserializer<'de>,
882				{
883					deserializer.deserialize_identifier(FieldVisitor)
884				}
885			}
886			struct ClassVisitor;
887			impl<'de> Visitor<'de> for ClassVisitor {
888				type Value = TrainTrip;
889				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
890					formatter.write_str("schema.org schema TrainTrip")
891				}
892				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
893				where
894					A: de::MapAccess<'de>,
895				{
896					let mut r#arrival_platform_property = None;
897					let mut r#arrival_station_property = None;
898					let mut r#departure_platform_property = None;
899					let mut r#departure_station_property = None;
900					let mut r#train_name_property = None;
901					let mut r#train_number_property = None;
902					let mut r#additional_type_property = None;
903					let mut r#alternate_name_property = None;
904					let mut r#description_property = None;
905					let mut r#disambiguating_description_property = None;
906					let mut r#identifier_property = None;
907					let mut r#image_property = None;
908					let mut r#main_entity_of_page_property = None;
909					let mut r#name_property = None;
910					let mut r#potential_action_property = None;
911					let mut r#same_as_property = None;
912					let mut r#subject_of_property = None;
913					let mut r#url_property = None;
914					let mut r#arrival_time_property = None;
915					let mut r#departure_time_property = None;
916					let mut r#itinerary_property = None;
917					let mut r#offers_property = None;
918					let mut r#part_of_trip_property = None;
919					let mut r#provider_property = None;
920					let mut r#sub_trip_property = None;
921					let mut r#trip_origin_property = None;
922					while let Some(key) = map.next_key::<Field>()? {
923						match key {
924							Field::ArrivalPlatform => {
925								if r#arrival_platform_property.is_some() {
926									return Err(<A::Error as de::Error>::duplicate_field(
927										"arrivalPlatform",
928									));
929								}
930								r#arrival_platform_property = Some({
931									struct DeserializeWith(Vec<ArrivalPlatformProperty>);
932									impl<'de> Deserialize<'de> for DeserializeWith {
933										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
934										where
935											D: Deserializer<'de>,
936										{
937											Ok(DeserializeWith(serde_with::As::<
938												serde_with::OneOrMany<serde_with::Same>,
939											>::deserialize(deserializer)?))
940										}
941									}
942									match map.next_value::<DeserializeWith>() {
943										Ok(deserialize_with) => deserialize_with.0,
944										Err(err) => {
945											return Err(err);
946										}
947									}
948								});
949							}
950							Field::ArrivalStation => {
951								if r#arrival_station_property.is_some() {
952									return Err(<A::Error as de::Error>::duplicate_field(
953										"arrivalStation",
954									));
955								}
956								r#arrival_station_property = Some({
957									struct DeserializeWith(Vec<ArrivalStationProperty>);
958									impl<'de> Deserialize<'de> for DeserializeWith {
959										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
960										where
961											D: Deserializer<'de>,
962										{
963											Ok(DeserializeWith(serde_with::As::<
964												serde_with::OneOrMany<serde_with::Same>,
965											>::deserialize(deserializer)?))
966										}
967									}
968									match map.next_value::<DeserializeWith>() {
969										Ok(deserialize_with) => deserialize_with.0,
970										Err(err) => {
971											return Err(err);
972										}
973									}
974								});
975							}
976							Field::DeparturePlatform => {
977								if r#departure_platform_property.is_some() {
978									return Err(<A::Error as de::Error>::duplicate_field(
979										"departurePlatform",
980									));
981								}
982								r#departure_platform_property = Some({
983									struct DeserializeWith(Vec<DeparturePlatformProperty>);
984									impl<'de> Deserialize<'de> for DeserializeWith {
985										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
986										where
987											D: Deserializer<'de>,
988										{
989											Ok(DeserializeWith(serde_with::As::<
990												serde_with::OneOrMany<serde_with::Same>,
991											>::deserialize(deserializer)?))
992										}
993									}
994									match map.next_value::<DeserializeWith>() {
995										Ok(deserialize_with) => deserialize_with.0,
996										Err(err) => {
997											return Err(err);
998										}
999									}
1000								});
1001							}
1002							Field::DepartureStation => {
1003								if r#departure_station_property.is_some() {
1004									return Err(<A::Error as de::Error>::duplicate_field(
1005										"departureStation",
1006									));
1007								}
1008								r#departure_station_property = Some({
1009									struct DeserializeWith(Vec<DepartureStationProperty>);
1010									impl<'de> Deserialize<'de> for DeserializeWith {
1011										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1012										where
1013											D: Deserializer<'de>,
1014										{
1015											Ok(DeserializeWith(serde_with::As::<
1016												serde_with::OneOrMany<serde_with::Same>,
1017											>::deserialize(deserializer)?))
1018										}
1019									}
1020									match map.next_value::<DeserializeWith>() {
1021										Ok(deserialize_with) => deserialize_with.0,
1022										Err(err) => {
1023											return Err(err);
1024										}
1025									}
1026								});
1027							}
1028							Field::TrainName => {
1029								if r#train_name_property.is_some() {
1030									return Err(<A::Error as de::Error>::duplicate_field(
1031										"trainName",
1032									));
1033								}
1034								r#train_name_property = Some({
1035									struct DeserializeWith(Vec<TrainNameProperty>);
1036									impl<'de> Deserialize<'de> for DeserializeWith {
1037										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1038										where
1039											D: Deserializer<'de>,
1040										{
1041											Ok(DeserializeWith(serde_with::As::<
1042												serde_with::OneOrMany<serde_with::Same>,
1043											>::deserialize(deserializer)?))
1044										}
1045									}
1046									match map.next_value::<DeserializeWith>() {
1047										Ok(deserialize_with) => deserialize_with.0,
1048										Err(err) => {
1049											return Err(err);
1050										}
1051									}
1052								});
1053							}
1054							Field::TrainNumber => {
1055								if r#train_number_property.is_some() {
1056									return Err(<A::Error as de::Error>::duplicate_field(
1057										"trainNumber",
1058									));
1059								}
1060								r#train_number_property = Some({
1061									struct DeserializeWith(Vec<TrainNumberProperty>);
1062									impl<'de> Deserialize<'de> for DeserializeWith {
1063										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1064										where
1065											D: Deserializer<'de>,
1066										{
1067											Ok(DeserializeWith(serde_with::As::<
1068												serde_with::OneOrMany<serde_with::Same>,
1069											>::deserialize(deserializer)?))
1070										}
1071									}
1072									match map.next_value::<DeserializeWith>() {
1073										Ok(deserialize_with) => deserialize_with.0,
1074										Err(err) => {
1075											return Err(err);
1076										}
1077									}
1078								});
1079							}
1080							Field::AdditionalType => {
1081								if r#additional_type_property.is_some() {
1082									return Err(<A::Error as de::Error>::duplicate_field(
1083										"additionalType",
1084									));
1085								}
1086								r#additional_type_property = Some({
1087									struct DeserializeWith(Vec<AdditionalTypeProperty>);
1088									impl<'de> Deserialize<'de> for DeserializeWith {
1089										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1090										where
1091											D: Deserializer<'de>,
1092										{
1093											Ok(DeserializeWith(serde_with::As::<
1094												serde_with::OneOrMany<serde_with::Same>,
1095											>::deserialize(deserializer)?))
1096										}
1097									}
1098									match map.next_value::<DeserializeWith>() {
1099										Ok(deserialize_with) => deserialize_with.0,
1100										Err(err) => {
1101											return Err(err);
1102										}
1103									}
1104								});
1105							}
1106							Field::AlternateName => {
1107								if r#alternate_name_property.is_some() {
1108									return Err(<A::Error as de::Error>::duplicate_field(
1109										"alternateName",
1110									));
1111								}
1112								r#alternate_name_property = Some({
1113									struct DeserializeWith(Vec<AlternateNameProperty>);
1114									impl<'de> Deserialize<'de> for DeserializeWith {
1115										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1116										where
1117											D: Deserializer<'de>,
1118										{
1119											Ok(DeserializeWith(serde_with::As::<
1120												serde_with::OneOrMany<serde_with::Same>,
1121											>::deserialize(deserializer)?))
1122										}
1123									}
1124									match map.next_value::<DeserializeWith>() {
1125										Ok(deserialize_with) => deserialize_with.0,
1126										Err(err) => {
1127											return Err(err);
1128										}
1129									}
1130								});
1131							}
1132							Field::Description => {
1133								if r#description_property.is_some() {
1134									return Err(<A::Error as de::Error>::duplicate_field(
1135										"description",
1136									));
1137								}
1138								r#description_property = Some({
1139									struct DeserializeWith(Vec<DescriptionProperty>);
1140									impl<'de> Deserialize<'de> for DeserializeWith {
1141										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1142										where
1143											D: Deserializer<'de>,
1144										{
1145											Ok(DeserializeWith(serde_with::As::<
1146												serde_with::OneOrMany<serde_with::Same>,
1147											>::deserialize(deserializer)?))
1148										}
1149									}
1150									match map.next_value::<DeserializeWith>() {
1151										Ok(deserialize_with) => deserialize_with.0,
1152										Err(err) => {
1153											return Err(err);
1154										}
1155									}
1156								});
1157							}
1158							Field::DisambiguatingDescription => {
1159								if r#disambiguating_description_property.is_some() {
1160									return Err(<A::Error as de::Error>::duplicate_field(
1161										"disambiguatingDescription",
1162									));
1163								}
1164								r#disambiguating_description_property = Some({
1165									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1166									impl<'de> Deserialize<'de> for DeserializeWith {
1167										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1168										where
1169											D: Deserializer<'de>,
1170										{
1171											Ok(DeserializeWith(serde_with::As::<
1172												serde_with::OneOrMany<serde_with::Same>,
1173											>::deserialize(deserializer)?))
1174										}
1175									}
1176									match map.next_value::<DeserializeWith>() {
1177										Ok(deserialize_with) => deserialize_with.0,
1178										Err(err) => {
1179											return Err(err);
1180										}
1181									}
1182								});
1183							}
1184							Field::Identifier => {
1185								if r#identifier_property.is_some() {
1186									return Err(<A::Error as de::Error>::duplicate_field(
1187										"identifier",
1188									));
1189								}
1190								r#identifier_property = Some({
1191									struct DeserializeWith(Vec<IdentifierProperty>);
1192									impl<'de> Deserialize<'de> for DeserializeWith {
1193										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1194										where
1195											D: Deserializer<'de>,
1196										{
1197											Ok(DeserializeWith(serde_with::As::<
1198												serde_with::OneOrMany<serde_with::Same>,
1199											>::deserialize(deserializer)?))
1200										}
1201									}
1202									match map.next_value::<DeserializeWith>() {
1203										Ok(deserialize_with) => deserialize_with.0,
1204										Err(err) => {
1205											return Err(err);
1206										}
1207									}
1208								});
1209							}
1210							Field::Image => {
1211								if r#image_property.is_some() {
1212									return Err(<A::Error as de::Error>::duplicate_field("image"));
1213								}
1214								r#image_property = Some({
1215									struct DeserializeWith(Vec<ImageProperty>);
1216									impl<'de> Deserialize<'de> for DeserializeWith {
1217										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1218										where
1219											D: Deserializer<'de>,
1220										{
1221											Ok(DeserializeWith(serde_with::As::<
1222												serde_with::OneOrMany<serde_with::Same>,
1223											>::deserialize(deserializer)?))
1224										}
1225									}
1226									match map.next_value::<DeserializeWith>() {
1227										Ok(deserialize_with) => deserialize_with.0,
1228										Err(err) => {
1229											return Err(err);
1230										}
1231									}
1232								});
1233							}
1234							Field::MainEntityOfPage => {
1235								if r#main_entity_of_page_property.is_some() {
1236									return Err(<A::Error as de::Error>::duplicate_field(
1237										"mainEntityOfPage",
1238									));
1239								}
1240								r#main_entity_of_page_property = Some({
1241									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1242									impl<'de> Deserialize<'de> for DeserializeWith {
1243										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1244										where
1245											D: Deserializer<'de>,
1246										{
1247											Ok(DeserializeWith(serde_with::As::<
1248												serde_with::OneOrMany<serde_with::Same>,
1249											>::deserialize(deserializer)?))
1250										}
1251									}
1252									match map.next_value::<DeserializeWith>() {
1253										Ok(deserialize_with) => deserialize_with.0,
1254										Err(err) => {
1255											return Err(err);
1256										}
1257									}
1258								});
1259							}
1260							Field::Name => {
1261								if r#name_property.is_some() {
1262									return Err(<A::Error as de::Error>::duplicate_field("name"));
1263								}
1264								r#name_property = Some({
1265									struct DeserializeWith(Vec<NameProperty>);
1266									impl<'de> Deserialize<'de> for DeserializeWith {
1267										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1268										where
1269											D: Deserializer<'de>,
1270										{
1271											Ok(DeserializeWith(serde_with::As::<
1272												serde_with::OneOrMany<serde_with::Same>,
1273											>::deserialize(deserializer)?))
1274										}
1275									}
1276									match map.next_value::<DeserializeWith>() {
1277										Ok(deserialize_with) => deserialize_with.0,
1278										Err(err) => {
1279											return Err(err);
1280										}
1281									}
1282								});
1283							}
1284							Field::PotentialAction => {
1285								if r#potential_action_property.is_some() {
1286									return Err(<A::Error as de::Error>::duplicate_field(
1287										"potentialAction",
1288									));
1289								}
1290								r#potential_action_property = Some({
1291									struct DeserializeWith(Vec<PotentialActionProperty>);
1292									impl<'de> Deserialize<'de> for DeserializeWith {
1293										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1294										where
1295											D: Deserializer<'de>,
1296										{
1297											Ok(DeserializeWith(serde_with::As::<
1298												serde_with::OneOrMany<serde_with::Same>,
1299											>::deserialize(deserializer)?))
1300										}
1301									}
1302									match map.next_value::<DeserializeWith>() {
1303										Ok(deserialize_with) => deserialize_with.0,
1304										Err(err) => {
1305											return Err(err);
1306										}
1307									}
1308								});
1309							}
1310							Field::SameAs => {
1311								if r#same_as_property.is_some() {
1312									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1313								}
1314								r#same_as_property = Some({
1315									struct DeserializeWith(Vec<SameAsProperty>);
1316									impl<'de> Deserialize<'de> for DeserializeWith {
1317										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1318										where
1319											D: Deserializer<'de>,
1320										{
1321											Ok(DeserializeWith(serde_with::As::<
1322												serde_with::OneOrMany<serde_with::Same>,
1323											>::deserialize(deserializer)?))
1324										}
1325									}
1326									match map.next_value::<DeserializeWith>() {
1327										Ok(deserialize_with) => deserialize_with.0,
1328										Err(err) => {
1329											return Err(err);
1330										}
1331									}
1332								});
1333							}
1334							Field::SubjectOf => {
1335								if r#subject_of_property.is_some() {
1336									return Err(<A::Error as de::Error>::duplicate_field(
1337										"subjectOf",
1338									));
1339								}
1340								r#subject_of_property = Some({
1341									struct DeserializeWith(Vec<SubjectOfProperty>);
1342									impl<'de> Deserialize<'de> for DeserializeWith {
1343										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1344										where
1345											D: Deserializer<'de>,
1346										{
1347											Ok(DeserializeWith(serde_with::As::<
1348												serde_with::OneOrMany<serde_with::Same>,
1349											>::deserialize(deserializer)?))
1350										}
1351									}
1352									match map.next_value::<DeserializeWith>() {
1353										Ok(deserialize_with) => deserialize_with.0,
1354										Err(err) => {
1355											return Err(err);
1356										}
1357									}
1358								});
1359							}
1360							Field::Url => {
1361								if r#url_property.is_some() {
1362									return Err(<A::Error as de::Error>::duplicate_field("url"));
1363								}
1364								r#url_property = Some({
1365									struct DeserializeWith(Vec<UrlProperty>);
1366									impl<'de> Deserialize<'de> for DeserializeWith {
1367										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1368										where
1369											D: Deserializer<'de>,
1370										{
1371											Ok(DeserializeWith(serde_with::As::<
1372												serde_with::OneOrMany<serde_with::Same>,
1373											>::deserialize(deserializer)?))
1374										}
1375									}
1376									match map.next_value::<DeserializeWith>() {
1377										Ok(deserialize_with) => deserialize_with.0,
1378										Err(err) => {
1379											return Err(err);
1380										}
1381									}
1382								});
1383							}
1384							Field::ArrivalTime => {
1385								if r#arrival_time_property.is_some() {
1386									return Err(<A::Error as de::Error>::duplicate_field(
1387										"arrivalTime",
1388									));
1389								}
1390								r#arrival_time_property = Some({
1391									struct DeserializeWith(Vec<ArrivalTimeProperty>);
1392									impl<'de> Deserialize<'de> for DeserializeWith {
1393										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1394										where
1395											D: Deserializer<'de>,
1396										{
1397											Ok(DeserializeWith(serde_with::As::<
1398												serde_with::OneOrMany<serde_with::Same>,
1399											>::deserialize(deserializer)?))
1400										}
1401									}
1402									match map.next_value::<DeserializeWith>() {
1403										Ok(deserialize_with) => deserialize_with.0,
1404										Err(err) => {
1405											return Err(err);
1406										}
1407									}
1408								});
1409							}
1410							Field::DepartureTime => {
1411								if r#departure_time_property.is_some() {
1412									return Err(<A::Error as de::Error>::duplicate_field(
1413										"departureTime",
1414									));
1415								}
1416								r#departure_time_property = Some({
1417									struct DeserializeWith(Vec<DepartureTimeProperty>);
1418									impl<'de> Deserialize<'de> for DeserializeWith {
1419										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1420										where
1421											D: Deserializer<'de>,
1422										{
1423											Ok(DeserializeWith(serde_with::As::<
1424												serde_with::OneOrMany<serde_with::Same>,
1425											>::deserialize(deserializer)?))
1426										}
1427									}
1428									match map.next_value::<DeserializeWith>() {
1429										Ok(deserialize_with) => deserialize_with.0,
1430										Err(err) => {
1431											return Err(err);
1432										}
1433									}
1434								});
1435							}
1436							Field::Itinerary => {
1437								if r#itinerary_property.is_some() {
1438									return Err(<A::Error as de::Error>::duplicate_field(
1439										"itinerary",
1440									));
1441								}
1442								r#itinerary_property = Some({
1443									struct DeserializeWith(Vec<ItineraryProperty>);
1444									impl<'de> Deserialize<'de> for DeserializeWith {
1445										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1446										where
1447											D: Deserializer<'de>,
1448										{
1449											Ok(DeserializeWith(serde_with::As::<
1450												serde_with::OneOrMany<serde_with::Same>,
1451											>::deserialize(deserializer)?))
1452										}
1453									}
1454									match map.next_value::<DeserializeWith>() {
1455										Ok(deserialize_with) => deserialize_with.0,
1456										Err(err) => {
1457											return Err(err);
1458										}
1459									}
1460								});
1461							}
1462							Field::Offers => {
1463								if r#offers_property.is_some() {
1464									return Err(<A::Error as de::Error>::duplicate_field("offers"));
1465								}
1466								r#offers_property = Some({
1467									struct DeserializeWith(Vec<OffersProperty>);
1468									impl<'de> Deserialize<'de> for DeserializeWith {
1469										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1470										where
1471											D: Deserializer<'de>,
1472										{
1473											Ok(DeserializeWith(serde_with::As::<
1474												serde_with::OneOrMany<serde_with::Same>,
1475											>::deserialize(deserializer)?))
1476										}
1477									}
1478									match map.next_value::<DeserializeWith>() {
1479										Ok(deserialize_with) => deserialize_with.0,
1480										Err(err) => {
1481											return Err(err);
1482										}
1483									}
1484								});
1485							}
1486							Field::PartOfTrip => {
1487								if r#part_of_trip_property.is_some() {
1488									return Err(<A::Error as de::Error>::duplicate_field(
1489										"partOfTrip",
1490									));
1491								}
1492								r#part_of_trip_property = Some({
1493									struct DeserializeWith(Vec<PartOfTripProperty>);
1494									impl<'de> Deserialize<'de> for DeserializeWith {
1495										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1496										where
1497											D: Deserializer<'de>,
1498										{
1499											Ok(DeserializeWith(serde_with::As::<
1500												serde_with::OneOrMany<serde_with::Same>,
1501											>::deserialize(deserializer)?))
1502										}
1503									}
1504									match map.next_value::<DeserializeWith>() {
1505										Ok(deserialize_with) => deserialize_with.0,
1506										Err(err) => {
1507											return Err(err);
1508										}
1509									}
1510								});
1511							}
1512							Field::Provider => {
1513								if r#provider_property.is_some() {
1514									return Err(<A::Error as de::Error>::duplicate_field(
1515										"provider",
1516									));
1517								}
1518								r#provider_property = Some({
1519									struct DeserializeWith(Vec<ProviderProperty>);
1520									impl<'de> Deserialize<'de> for DeserializeWith {
1521										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1522										where
1523											D: Deserializer<'de>,
1524										{
1525											Ok(DeserializeWith(serde_with::As::<
1526												serde_with::OneOrMany<serde_with::Same>,
1527											>::deserialize(deserializer)?))
1528										}
1529									}
1530									match map.next_value::<DeserializeWith>() {
1531										Ok(deserialize_with) => deserialize_with.0,
1532										Err(err) => {
1533											return Err(err);
1534										}
1535									}
1536								});
1537							}
1538							Field::SubTrip => {
1539								if r#sub_trip_property.is_some() {
1540									return Err(<A::Error as de::Error>::duplicate_field(
1541										"subTrip",
1542									));
1543								}
1544								r#sub_trip_property = Some({
1545									struct DeserializeWith(Vec<SubTripProperty>);
1546									impl<'de> Deserialize<'de> for DeserializeWith {
1547										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1548										where
1549											D: Deserializer<'de>,
1550										{
1551											Ok(DeserializeWith(serde_with::As::<
1552												serde_with::OneOrMany<serde_with::Same>,
1553											>::deserialize(deserializer)?))
1554										}
1555									}
1556									match map.next_value::<DeserializeWith>() {
1557										Ok(deserialize_with) => deserialize_with.0,
1558										Err(err) => {
1559											return Err(err);
1560										}
1561									}
1562								});
1563							}
1564							Field::TripOrigin => {
1565								if r#trip_origin_property.is_some() {
1566									return Err(<A::Error as de::Error>::duplicate_field(
1567										"tripOrigin",
1568									));
1569								}
1570								r#trip_origin_property = Some({
1571									struct DeserializeWith(Vec<TripOriginProperty>);
1572									impl<'de> Deserialize<'de> for DeserializeWith {
1573										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1574										where
1575											D: Deserializer<'de>,
1576										{
1577											Ok(DeserializeWith(serde_with::As::<
1578												serde_with::OneOrMany<serde_with::Same>,
1579											>::deserialize(deserializer)?))
1580										}
1581									}
1582									match map.next_value::<DeserializeWith>() {
1583										Ok(deserialize_with) => deserialize_with.0,
1584										Err(err) => {
1585											return Err(err);
1586										}
1587									}
1588								});
1589							}
1590							Field::Ignore => {
1591								let _ = map.next_value::<de::IgnoredAny>()?;
1592							}
1593						}
1594					}
1595					Ok(TrainTrip {
1596						r#arrival_platform: r#arrival_platform_property.unwrap_or_default(),
1597						r#arrival_station: r#arrival_station_property.unwrap_or_default(),
1598						r#departure_platform: r#departure_platform_property.unwrap_or_default(),
1599						r#departure_station: r#departure_station_property.unwrap_or_default(),
1600						r#train_name: r#train_name_property.unwrap_or_default(),
1601						r#train_number: r#train_number_property.unwrap_or_default(),
1602						r#additional_type: r#additional_type_property.unwrap_or_default(),
1603						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1604						r#description: r#description_property.unwrap_or_default(),
1605						r#disambiguating_description: r#disambiguating_description_property
1606							.unwrap_or_default(),
1607						r#identifier: r#identifier_property.unwrap_or_default(),
1608						r#image: r#image_property.unwrap_or_default(),
1609						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1610						r#name: r#name_property.unwrap_or_default(),
1611						r#potential_action: r#potential_action_property.unwrap_or_default(),
1612						r#same_as: r#same_as_property.unwrap_or_default(),
1613						r#subject_of: r#subject_of_property.unwrap_or_default(),
1614						r#url: r#url_property.unwrap_or_default(),
1615						r#arrival_time: r#arrival_time_property.unwrap_or_default(),
1616						r#departure_time: r#departure_time_property.unwrap_or_default(),
1617						r#itinerary: r#itinerary_property.unwrap_or_default(),
1618						r#offers: r#offers_property.unwrap_or_default(),
1619						r#part_of_trip: r#part_of_trip_property.unwrap_or_default(),
1620						r#provider: r#provider_property.unwrap_or_default(),
1621						r#sub_trip: r#sub_trip_property.unwrap_or_default(),
1622						r#trip_origin: r#trip_origin_property.unwrap_or_default(),
1623					})
1624				}
1625			}
1626			const FIELDS: &[&str] = &[
1627				"arrivalPlatform",
1628				"arrivalStation",
1629				"departurePlatform",
1630				"departureStation",
1631				"trainName",
1632				"trainNumber",
1633				"additionalType",
1634				"alternateName",
1635				"description",
1636				"disambiguatingDescription",
1637				"identifier",
1638				"image",
1639				"mainEntityOfPage",
1640				"name",
1641				"potentialAction",
1642				"sameAs",
1643				"subjectOf",
1644				"url",
1645				"arrivalTime",
1646				"departureTime",
1647				"itinerary",
1648				"offers",
1649				"partOfTrip",
1650				"provider",
1651				"subTrip",
1652				"tripOrigin",
1653			];
1654			deserializer.deserialize_struct("TrainTrip", FIELDS, ClassVisitor)
1655		}
1656	}
1657}
schema_org_types/schemas/classes/train_trip.rs

schema_org_types/schemas/classes/
train_trip.rs
