schema_org_types/schemas/classes/
ligament.rs

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