schema_org_types/schemas/classes/
join_action.rs

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

schema_org_types/schemas/classes/
join_action.rs
