schema_org_types/schemas/classes/
track_action.rs

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

schema_org_types/schemas/classes/
track_action.rs
