schema_org_types/schemas/classes/
medical_code.rs

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

schema_org_types/schemas/classes/
medical_code.rs
