schema_org_types/schemas/classes/
medical_intangible.rs

1use super::*;
2/// <https://schema.org/MedicalIntangible>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct MedicalIntangible {
6	/// <https://schema.org/code>
7	pub r#code: Vec<CodeProperty>,
8	/// <https://schema.org/funding>
9	pub r#funding: Vec<FundingProperty>,
10	/// <https://schema.org/guideline>
11	pub r#guideline: Vec<GuidelineProperty>,
12	/// <https://schema.org/legalStatus>
13	pub r#legal_status: Vec<LegalStatusProperty>,
14	/// <https://schema.org/medicineSystem>
15	pub r#medicine_system: Vec<MedicineSystemProperty>,
16	/// <https://schema.org/recognizingAuthority>
17	pub r#recognizing_authority: Vec<RecognizingAuthorityProperty>,
18	/// <https://schema.org/relevantSpecialty>
19	pub r#relevant_specialty: Vec<RelevantSpecialtyProperty>,
20	/// <https://schema.org/study>
21	pub r#study: Vec<StudyProperty>,
22	/// <https://schema.org/additionalType>
23	pub r#additional_type: Vec<AdditionalTypeProperty>,
24	/// <https://schema.org/alternateName>
25	pub r#alternate_name: Vec<AlternateNameProperty>,
26	/// <https://schema.org/description>
27	pub r#description: Vec<DescriptionProperty>,
28	/// <https://schema.org/disambiguatingDescription>
29	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
30	/// <https://schema.org/identifier>
31	pub r#identifier: Vec<IdentifierProperty>,
32	/// <https://schema.org/image>
33	pub r#image: Vec<ImageProperty>,
34	/// <https://schema.org/mainEntityOfPage>
35	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
36	/// <https://schema.org/name>
37	pub r#name: Vec<NameProperty>,
38	/// <https://schema.org/potentialAction>
39	pub r#potential_action: Vec<PotentialActionProperty>,
40	/// <https://schema.org/sameAs>
41	pub r#same_as: Vec<SameAsProperty>,
42	/// <https://schema.org/subjectOf>
43	pub r#subject_of: Vec<SubjectOfProperty>,
44	/// <https://schema.org/url>
45	pub r#url: Vec<UrlProperty>,
46}
47/// This trait is for properties from <https://schema.org/MedicalIntangible>.
48pub trait MedicalIntangibleTrait {}
49impl MedicalIntangibleTrait for MedicalIntangible {}
50impl MedicalEntityTrait for MedicalIntangible {
51	fn get_code(&self) -> &[CodeProperty] {
52		self.r#code.as_slice()
53	}
54	fn take_code(&mut self) -> Vec<CodeProperty> {
55		std::mem::take(&mut self.r#code)
56	}
57	fn get_funding(&self) -> &[FundingProperty] {
58		self.r#funding.as_slice()
59	}
60	fn take_funding(&mut self) -> Vec<FundingProperty> {
61		std::mem::take(&mut self.r#funding)
62	}
63	fn get_guideline(&self) -> &[GuidelineProperty] {
64		self.r#guideline.as_slice()
65	}
66	fn take_guideline(&mut self) -> Vec<GuidelineProperty> {
67		std::mem::take(&mut self.r#guideline)
68	}
69	fn get_legal_status(&self) -> &[LegalStatusProperty] {
70		self.r#legal_status.as_slice()
71	}
72	fn take_legal_status(&mut self) -> Vec<LegalStatusProperty> {
73		std::mem::take(&mut self.r#legal_status)
74	}
75	fn get_medicine_system(&self) -> &[MedicineSystemProperty] {
76		self.r#medicine_system.as_slice()
77	}
78	fn take_medicine_system(&mut self) -> Vec<MedicineSystemProperty> {
79		std::mem::take(&mut self.r#medicine_system)
80	}
81	fn get_recognizing_authority(&self) -> &[RecognizingAuthorityProperty] {
82		self.r#recognizing_authority.as_slice()
83	}
84	fn take_recognizing_authority(&mut self) -> Vec<RecognizingAuthorityProperty> {
85		std::mem::take(&mut self.r#recognizing_authority)
86	}
87	fn get_relevant_specialty(&self) -> &[RelevantSpecialtyProperty] {
88		self.r#relevant_specialty.as_slice()
89	}
90	fn take_relevant_specialty(&mut self) -> Vec<RelevantSpecialtyProperty> {
91		std::mem::take(&mut self.r#relevant_specialty)
92	}
93	fn get_study(&self) -> &[StudyProperty] {
94		self.r#study.as_slice()
95	}
96	fn take_study(&mut self) -> Vec<StudyProperty> {
97		std::mem::take(&mut self.r#study)
98	}
99}
100impl ThingTrait for MedicalIntangible {
101	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
102		self.r#additional_type.as_slice()
103	}
104	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
105		std::mem::take(&mut self.r#additional_type)
106	}
107	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
108		self.r#alternate_name.as_slice()
109	}
110	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
111		std::mem::take(&mut self.r#alternate_name)
112	}
113	fn get_description(&self) -> &[DescriptionProperty] {
114		self.r#description.as_slice()
115	}
116	fn take_description(&mut self) -> Vec<DescriptionProperty> {
117		std::mem::take(&mut self.r#description)
118	}
119	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
120		self.r#disambiguating_description.as_slice()
121	}
122	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
123		std::mem::take(&mut self.r#disambiguating_description)
124	}
125	fn get_identifier(&self) -> &[IdentifierProperty] {
126		self.r#identifier.as_slice()
127	}
128	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
129		std::mem::take(&mut self.r#identifier)
130	}
131	fn get_image(&self) -> &[ImageProperty] {
132		self.r#image.as_slice()
133	}
134	fn take_image(&mut self) -> Vec<ImageProperty> {
135		std::mem::take(&mut self.r#image)
136	}
137	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
138		self.r#main_entity_of_page.as_slice()
139	}
140	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
141		std::mem::take(&mut self.r#main_entity_of_page)
142	}
143	fn get_name(&self) -> &[NameProperty] {
144		self.r#name.as_slice()
145	}
146	fn take_name(&mut self) -> Vec<NameProperty> {
147		std::mem::take(&mut self.r#name)
148	}
149	fn get_potential_action(&self) -> &[PotentialActionProperty] {
150		self.r#potential_action.as_slice()
151	}
152	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
153		std::mem::take(&mut self.r#potential_action)
154	}
155	fn get_same_as(&self) -> &[SameAsProperty] {
156		self.r#same_as.as_slice()
157	}
158	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
159		std::mem::take(&mut self.r#same_as)
160	}
161	fn get_subject_of(&self) -> &[SubjectOfProperty] {
162		self.r#subject_of.as_slice()
163	}
164	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
165		std::mem::take(&mut self.r#subject_of)
166	}
167	fn get_url(&self) -> &[UrlProperty] {
168		self.r#url.as_slice()
169	}
170	fn take_url(&mut self) -> Vec<UrlProperty> {
171		std::mem::take(&mut self.r#url)
172	}
173}
174#[cfg(feature = "serde")]
175mod serde {
176	use std::{fmt, fmt::Formatter};
177
178	use ::serde::{
179		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
180	};
181
182	use super::*;
183	impl Serialize for MedicalIntangible {
184		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
185		where
186			S: Serializer,
187		{
188			let len: usize = [
189				!Vec::is_empty(&self.r#code) as usize,
190				!Vec::is_empty(&self.r#funding) as usize,
191				!Vec::is_empty(&self.r#guideline) as usize,
192				!Vec::is_empty(&self.r#legal_status) as usize,
193				!Vec::is_empty(&self.r#medicine_system) as usize,
194				!Vec::is_empty(&self.r#recognizing_authority) as usize,
195				!Vec::is_empty(&self.r#relevant_specialty) as usize,
196				!Vec::is_empty(&self.r#study) as usize,
197				!Vec::is_empty(&self.r#additional_type) as usize,
198				!Vec::is_empty(&self.r#alternate_name) as usize,
199				!Vec::is_empty(&self.r#description) as usize,
200				!Vec::is_empty(&self.r#disambiguating_description) as usize,
201				!Vec::is_empty(&self.r#identifier) as usize,
202				!Vec::is_empty(&self.r#image) as usize,
203				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
204				!Vec::is_empty(&self.r#name) as usize,
205				!Vec::is_empty(&self.r#potential_action) as usize,
206				!Vec::is_empty(&self.r#same_as) as usize,
207				!Vec::is_empty(&self.r#subject_of) as usize,
208				!Vec::is_empty(&self.r#url) as usize,
209			]
210			.iter()
211			.sum();
212			let mut serialize_struct =
213				Serializer::serialize_struct(serializer, "MedicalIntangible", len)?;
214			if !Vec::is_empty(&self.r#code) {
215				serialize_struct.serialize_field("code", {
216					struct SerializeWith<'a>(&'a Vec<CodeProperty>);
217					impl<'a> Serialize for SerializeWith<'a> {
218						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
219						where
220							S: Serializer,
221						{
222							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
223								self.0, serializer,
224							)
225						}
226					}
227					&SerializeWith(&self.r#code)
228				})?;
229			} else {
230				serialize_struct.skip_field("code")?;
231			}
232			if !Vec::is_empty(&self.r#funding) {
233				serialize_struct.serialize_field("funding", {
234					struct SerializeWith<'a>(&'a Vec<FundingProperty>);
235					impl<'a> Serialize for SerializeWith<'a> {
236						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
237						where
238							S: Serializer,
239						{
240							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
241								self.0, serializer,
242							)
243						}
244					}
245					&SerializeWith(&self.r#funding)
246				})?;
247			} else {
248				serialize_struct.skip_field("funding")?;
249			}
250			if !Vec::is_empty(&self.r#guideline) {
251				serialize_struct.serialize_field("guideline", {
252					struct SerializeWith<'a>(&'a Vec<GuidelineProperty>);
253					impl<'a> Serialize for SerializeWith<'a> {
254						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
255						where
256							S: Serializer,
257						{
258							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
259								self.0, serializer,
260							)
261						}
262					}
263					&SerializeWith(&self.r#guideline)
264				})?;
265			} else {
266				serialize_struct.skip_field("guideline")?;
267			}
268			if !Vec::is_empty(&self.r#legal_status) {
269				serialize_struct.serialize_field("legalStatus", {
270					struct SerializeWith<'a>(&'a Vec<LegalStatusProperty>);
271					impl<'a> Serialize for SerializeWith<'a> {
272						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
273						where
274							S: Serializer,
275						{
276							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
277								self.0, serializer,
278							)
279						}
280					}
281					&SerializeWith(&self.r#legal_status)
282				})?;
283			} else {
284				serialize_struct.skip_field("legalStatus")?;
285			}
286			if !Vec::is_empty(&self.r#medicine_system) {
287				serialize_struct.serialize_field("medicineSystem", {
288					struct SerializeWith<'a>(&'a Vec<MedicineSystemProperty>);
289					impl<'a> Serialize for SerializeWith<'a> {
290						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
291						where
292							S: Serializer,
293						{
294							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
295								self.0, serializer,
296							)
297						}
298					}
299					&SerializeWith(&self.r#medicine_system)
300				})?;
301			} else {
302				serialize_struct.skip_field("medicineSystem")?;
303			}
304			if !Vec::is_empty(&self.r#recognizing_authority) {
305				serialize_struct.serialize_field("recognizingAuthority", {
306					struct SerializeWith<'a>(&'a Vec<RecognizingAuthorityProperty>);
307					impl<'a> Serialize for SerializeWith<'a> {
308						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
309						where
310							S: Serializer,
311						{
312							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
313								self.0, serializer,
314							)
315						}
316					}
317					&SerializeWith(&self.r#recognizing_authority)
318				})?;
319			} else {
320				serialize_struct.skip_field("recognizingAuthority")?;
321			}
322			if !Vec::is_empty(&self.r#relevant_specialty) {
323				serialize_struct.serialize_field("relevantSpecialty", {
324					struct SerializeWith<'a>(&'a Vec<RelevantSpecialtyProperty>);
325					impl<'a> Serialize for SerializeWith<'a> {
326						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
327						where
328							S: Serializer,
329						{
330							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
331								self.0, serializer,
332							)
333						}
334					}
335					&SerializeWith(&self.r#relevant_specialty)
336				})?;
337			} else {
338				serialize_struct.skip_field("relevantSpecialty")?;
339			}
340			if !Vec::is_empty(&self.r#study) {
341				serialize_struct.serialize_field("study", {
342					struct SerializeWith<'a>(&'a Vec<StudyProperty>);
343					impl<'a> Serialize for SerializeWith<'a> {
344						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
345						where
346							S: Serializer,
347						{
348							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
349								self.0, serializer,
350							)
351						}
352					}
353					&SerializeWith(&self.r#study)
354				})?;
355			} else {
356				serialize_struct.skip_field("study")?;
357			}
358			if !Vec::is_empty(&self.r#additional_type) {
359				serialize_struct.serialize_field("additionalType", {
360					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
361					impl<'a> Serialize for SerializeWith<'a> {
362						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
363						where
364							S: Serializer,
365						{
366							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
367								self.0, serializer,
368							)
369						}
370					}
371					&SerializeWith(&self.r#additional_type)
372				})?;
373			} else {
374				serialize_struct.skip_field("additionalType")?;
375			}
376			if !Vec::is_empty(&self.r#alternate_name) {
377				serialize_struct.serialize_field("alternateName", {
378					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
379					impl<'a> Serialize for SerializeWith<'a> {
380						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
381						where
382							S: Serializer,
383						{
384							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
385								self.0, serializer,
386							)
387						}
388					}
389					&SerializeWith(&self.r#alternate_name)
390				})?;
391			} else {
392				serialize_struct.skip_field("alternateName")?;
393			}
394			if !Vec::is_empty(&self.r#description) {
395				serialize_struct.serialize_field("description", {
396					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
397					impl<'a> Serialize for SerializeWith<'a> {
398						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
399						where
400							S: Serializer,
401						{
402							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
403								self.0, serializer,
404							)
405						}
406					}
407					&SerializeWith(&self.r#description)
408				})?;
409			} else {
410				serialize_struct.skip_field("description")?;
411			}
412			if !Vec::is_empty(&self.r#disambiguating_description) {
413				serialize_struct.serialize_field("disambiguatingDescription", {
414					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
415					impl<'a> Serialize for SerializeWith<'a> {
416						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
417						where
418							S: Serializer,
419						{
420							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
421								self.0, serializer,
422							)
423						}
424					}
425					&SerializeWith(&self.r#disambiguating_description)
426				})?;
427			} else {
428				serialize_struct.skip_field("disambiguatingDescription")?;
429			}
430			if !Vec::is_empty(&self.r#identifier) {
431				serialize_struct.serialize_field("identifier", {
432					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
433					impl<'a> Serialize for SerializeWith<'a> {
434						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
435						where
436							S: Serializer,
437						{
438							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
439								self.0, serializer,
440							)
441						}
442					}
443					&SerializeWith(&self.r#identifier)
444				})?;
445			} else {
446				serialize_struct.skip_field("identifier")?;
447			}
448			if !Vec::is_empty(&self.r#image) {
449				serialize_struct.serialize_field("image", {
450					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
451					impl<'a> Serialize for SerializeWith<'a> {
452						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
453						where
454							S: Serializer,
455						{
456							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
457								self.0, serializer,
458							)
459						}
460					}
461					&SerializeWith(&self.r#image)
462				})?;
463			} else {
464				serialize_struct.skip_field("image")?;
465			}
466			if !Vec::is_empty(&self.r#main_entity_of_page) {
467				serialize_struct.serialize_field("mainEntityOfPage", {
468					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
469					impl<'a> Serialize for SerializeWith<'a> {
470						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
471						where
472							S: Serializer,
473						{
474							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
475								self.0, serializer,
476							)
477						}
478					}
479					&SerializeWith(&self.r#main_entity_of_page)
480				})?;
481			} else {
482				serialize_struct.skip_field("mainEntityOfPage")?;
483			}
484			if !Vec::is_empty(&self.r#name) {
485				serialize_struct.serialize_field("name", {
486					struct SerializeWith<'a>(&'a Vec<NameProperty>);
487					impl<'a> Serialize for SerializeWith<'a> {
488						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
489						where
490							S: Serializer,
491						{
492							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
493								self.0, serializer,
494							)
495						}
496					}
497					&SerializeWith(&self.r#name)
498				})?;
499			} else {
500				serialize_struct.skip_field("name")?;
501			}
502			if !Vec::is_empty(&self.r#potential_action) {
503				serialize_struct.serialize_field("potentialAction", {
504					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
505					impl<'a> Serialize for SerializeWith<'a> {
506						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
507						where
508							S: Serializer,
509						{
510							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
511								self.0, serializer,
512							)
513						}
514					}
515					&SerializeWith(&self.r#potential_action)
516				})?;
517			} else {
518				serialize_struct.skip_field("potentialAction")?;
519			}
520			if !Vec::is_empty(&self.r#same_as) {
521				serialize_struct.serialize_field("sameAs", {
522					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
523					impl<'a> Serialize for SerializeWith<'a> {
524						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
525						where
526							S: Serializer,
527						{
528							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
529								self.0, serializer,
530							)
531						}
532					}
533					&SerializeWith(&self.r#same_as)
534				})?;
535			} else {
536				serialize_struct.skip_field("sameAs")?;
537			}
538			if !Vec::is_empty(&self.r#subject_of) {
539				serialize_struct.serialize_field("subjectOf", {
540					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
541					impl<'a> Serialize for SerializeWith<'a> {
542						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
543						where
544							S: Serializer,
545						{
546							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
547								self.0, serializer,
548							)
549						}
550					}
551					&SerializeWith(&self.r#subject_of)
552				})?;
553			} else {
554				serialize_struct.skip_field("subjectOf")?;
555			}
556			if !Vec::is_empty(&self.r#url) {
557				serialize_struct.serialize_field("url", {
558					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
559					impl<'a> Serialize for SerializeWith<'a> {
560						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
561						where
562							S: Serializer,
563						{
564							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
565								self.0, serializer,
566							)
567						}
568					}
569					&SerializeWith(&self.r#url)
570				})?;
571			} else {
572				serialize_struct.skip_field("url")?;
573			}
574			serialize_struct.end()
575		}
576	}
577	impl<'de> Deserialize<'de> for MedicalIntangible {
578		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
579		where
580			D: Deserializer<'de>,
581		{
582			enum Field {
583				Code,
584				Funding,
585				Guideline,
586				LegalStatus,
587				MedicineSystem,
588				RecognizingAuthority,
589				RelevantSpecialty,
590				Study,
591				AdditionalType,
592				AlternateName,
593				Description,
594				DisambiguatingDescription,
595				Identifier,
596				Image,
597				MainEntityOfPage,
598				Name,
599				PotentialAction,
600				SameAs,
601				SubjectOf,
602				Url,
603				Ignore,
604			}
605			struct FieldVisitor;
606			impl<'de> Visitor<'de> for FieldVisitor {
607				type Value = Field;
608				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
609					formatter.write_str("field identifier")
610				}
611				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
612				where
613					E: de::Error,
614				{
615					match value {
616						"code" => Ok(Field::Code),
617						"funding" => Ok(Field::Funding),
618						"guideline" => Ok(Field::Guideline),
619						"legalStatus" => Ok(Field::LegalStatus),
620						"medicineSystem" => Ok(Field::MedicineSystem),
621						"recognizingAuthority" => Ok(Field::RecognizingAuthority),
622						"relevantSpecialty" => Ok(Field::RelevantSpecialty),
623						"study" => Ok(Field::Study),
624						"additionalType" => Ok(Field::AdditionalType),
625						"alternateName" => Ok(Field::AlternateName),
626						"description" => Ok(Field::Description),
627						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
628						"identifier" => Ok(Field::Identifier),
629						"image" => Ok(Field::Image),
630						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
631						"name" => Ok(Field::Name),
632						"potentialAction" => Ok(Field::PotentialAction),
633						"sameAs" => Ok(Field::SameAs),
634						"subjectOf" => Ok(Field::SubjectOf),
635						"url" => Ok(Field::Url),
636						"id" | "type" => Ok(Field::Ignore),
637						_ => Err(de::Error::unknown_field(value, FIELDS)),
638					}
639				}
640				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
641				where
642					E: de::Error,
643				{
644					match value {
645						b"code" => Ok(Field::Code),
646						b"funding" => Ok(Field::Funding),
647						b"guideline" => Ok(Field::Guideline),
648						b"legalStatus" => Ok(Field::LegalStatus),
649						b"medicineSystem" => Ok(Field::MedicineSystem),
650						b"recognizingAuthority" => Ok(Field::RecognizingAuthority),
651						b"relevantSpecialty" => Ok(Field::RelevantSpecialty),
652						b"study" => Ok(Field::Study),
653						b"additionalType" => Ok(Field::AdditionalType),
654						b"alternateName" => Ok(Field::AlternateName),
655						b"description" => Ok(Field::Description),
656						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
657						b"identifier" => Ok(Field::Identifier),
658						b"image" => Ok(Field::Image),
659						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
660						b"name" => Ok(Field::Name),
661						b"potentialAction" => Ok(Field::PotentialAction),
662						b"sameAs" => Ok(Field::SameAs),
663						b"subjectOf" => Ok(Field::SubjectOf),
664						b"url" => Ok(Field::Url),
665						b"id" | b"type" => Ok(Field::Ignore),
666						_ => {
667							let value = &String::from_utf8_lossy(value);
668							Err(de::Error::unknown_field(value, FIELDS))
669						}
670					}
671				}
672			}
673			impl<'de> Deserialize<'de> for Field {
674				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
675				where
676					D: Deserializer<'de>,
677				{
678					deserializer.deserialize_identifier(FieldVisitor)
679				}
680			}
681			struct ClassVisitor;
682			impl<'de> Visitor<'de> for ClassVisitor {
683				type Value = MedicalIntangible;
684				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
685					formatter.write_str("schema.org schema MedicalIntangible")
686				}
687				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
688				where
689					A: de::MapAccess<'de>,
690				{
691					let mut r#code_property = None;
692					let mut r#funding_property = None;
693					let mut r#guideline_property = None;
694					let mut r#legal_status_property = None;
695					let mut r#medicine_system_property = None;
696					let mut r#recognizing_authority_property = None;
697					let mut r#relevant_specialty_property = None;
698					let mut r#study_property = None;
699					let mut r#additional_type_property = None;
700					let mut r#alternate_name_property = None;
701					let mut r#description_property = None;
702					let mut r#disambiguating_description_property = None;
703					let mut r#identifier_property = None;
704					let mut r#image_property = None;
705					let mut r#main_entity_of_page_property = None;
706					let mut r#name_property = None;
707					let mut r#potential_action_property = None;
708					let mut r#same_as_property = None;
709					let mut r#subject_of_property = None;
710					let mut r#url_property = None;
711					while let Some(key) = map.next_key::<Field>()? {
712						match key {
713							Field::Code => {
714								if r#code_property.is_some() {
715									return Err(<A::Error as de::Error>::duplicate_field("code"));
716								}
717								r#code_property = Some({
718									struct DeserializeWith(Vec<CodeProperty>);
719									impl<'de> Deserialize<'de> for DeserializeWith {
720										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
721										where
722											D: Deserializer<'de>,
723										{
724											Ok(DeserializeWith(serde_with::As::<
725												serde_with::OneOrMany<serde_with::Same>,
726											>::deserialize(deserializer)?))
727										}
728									}
729									match map.next_value::<DeserializeWith>() {
730										Ok(deserialize_with) => deserialize_with.0,
731										Err(err) => {
732											return Err(err);
733										}
734									}
735								});
736							}
737							Field::Funding => {
738								if r#funding_property.is_some() {
739									return Err(<A::Error as de::Error>::duplicate_field(
740										"funding",
741									));
742								}
743								r#funding_property = Some({
744									struct DeserializeWith(Vec<FundingProperty>);
745									impl<'de> Deserialize<'de> for DeserializeWith {
746										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
747										where
748											D: Deserializer<'de>,
749										{
750											Ok(DeserializeWith(serde_with::As::<
751												serde_with::OneOrMany<serde_with::Same>,
752											>::deserialize(deserializer)?))
753										}
754									}
755									match map.next_value::<DeserializeWith>() {
756										Ok(deserialize_with) => deserialize_with.0,
757										Err(err) => {
758											return Err(err);
759										}
760									}
761								});
762							}
763							Field::Guideline => {
764								if r#guideline_property.is_some() {
765									return Err(<A::Error as de::Error>::duplicate_field(
766										"guideline",
767									));
768								}
769								r#guideline_property = Some({
770									struct DeserializeWith(Vec<GuidelineProperty>);
771									impl<'de> Deserialize<'de> for DeserializeWith {
772										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
773										where
774											D: Deserializer<'de>,
775										{
776											Ok(DeserializeWith(serde_with::As::<
777												serde_with::OneOrMany<serde_with::Same>,
778											>::deserialize(deserializer)?))
779										}
780									}
781									match map.next_value::<DeserializeWith>() {
782										Ok(deserialize_with) => deserialize_with.0,
783										Err(err) => {
784											return Err(err);
785										}
786									}
787								});
788							}
789							Field::LegalStatus => {
790								if r#legal_status_property.is_some() {
791									return Err(<A::Error as de::Error>::duplicate_field(
792										"legalStatus",
793									));
794								}
795								r#legal_status_property = Some({
796									struct DeserializeWith(Vec<LegalStatusProperty>);
797									impl<'de> Deserialize<'de> for DeserializeWith {
798										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
799										where
800											D: Deserializer<'de>,
801										{
802											Ok(DeserializeWith(serde_with::As::<
803												serde_with::OneOrMany<serde_with::Same>,
804											>::deserialize(deserializer)?))
805										}
806									}
807									match map.next_value::<DeserializeWith>() {
808										Ok(deserialize_with) => deserialize_with.0,
809										Err(err) => {
810											return Err(err);
811										}
812									}
813								});
814							}
815							Field::MedicineSystem => {
816								if r#medicine_system_property.is_some() {
817									return Err(<A::Error as de::Error>::duplicate_field(
818										"medicineSystem",
819									));
820								}
821								r#medicine_system_property = Some({
822									struct DeserializeWith(Vec<MedicineSystemProperty>);
823									impl<'de> Deserialize<'de> for DeserializeWith {
824										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
825										where
826											D: Deserializer<'de>,
827										{
828											Ok(DeserializeWith(serde_with::As::<
829												serde_with::OneOrMany<serde_with::Same>,
830											>::deserialize(deserializer)?))
831										}
832									}
833									match map.next_value::<DeserializeWith>() {
834										Ok(deserialize_with) => deserialize_with.0,
835										Err(err) => {
836											return Err(err);
837										}
838									}
839								});
840							}
841							Field::RecognizingAuthority => {
842								if r#recognizing_authority_property.is_some() {
843									return Err(<A::Error as de::Error>::duplicate_field(
844										"recognizingAuthority",
845									));
846								}
847								r#recognizing_authority_property = Some({
848									struct DeserializeWith(Vec<RecognizingAuthorityProperty>);
849									impl<'de> Deserialize<'de> for DeserializeWith {
850										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
851										where
852											D: Deserializer<'de>,
853										{
854											Ok(DeserializeWith(serde_with::As::<
855												serde_with::OneOrMany<serde_with::Same>,
856											>::deserialize(deserializer)?))
857										}
858									}
859									match map.next_value::<DeserializeWith>() {
860										Ok(deserialize_with) => deserialize_with.0,
861										Err(err) => {
862											return Err(err);
863										}
864									}
865								});
866							}
867							Field::RelevantSpecialty => {
868								if r#relevant_specialty_property.is_some() {
869									return Err(<A::Error as de::Error>::duplicate_field(
870										"relevantSpecialty",
871									));
872								}
873								r#relevant_specialty_property = Some({
874									struct DeserializeWith(Vec<RelevantSpecialtyProperty>);
875									impl<'de> Deserialize<'de> for DeserializeWith {
876										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
877										where
878											D: Deserializer<'de>,
879										{
880											Ok(DeserializeWith(serde_with::As::<
881												serde_with::OneOrMany<serde_with::Same>,
882											>::deserialize(deserializer)?))
883										}
884									}
885									match map.next_value::<DeserializeWith>() {
886										Ok(deserialize_with) => deserialize_with.0,
887										Err(err) => {
888											return Err(err);
889										}
890									}
891								});
892							}
893							Field::Study => {
894								if r#study_property.is_some() {
895									return Err(<A::Error as de::Error>::duplicate_field("study"));
896								}
897								r#study_property = Some({
898									struct DeserializeWith(Vec<StudyProperty>);
899									impl<'de> Deserialize<'de> for DeserializeWith {
900										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
901										where
902											D: Deserializer<'de>,
903										{
904											Ok(DeserializeWith(serde_with::As::<
905												serde_with::OneOrMany<serde_with::Same>,
906											>::deserialize(deserializer)?))
907										}
908									}
909									match map.next_value::<DeserializeWith>() {
910										Ok(deserialize_with) => deserialize_with.0,
911										Err(err) => {
912											return Err(err);
913										}
914									}
915								});
916							}
917							Field::AdditionalType => {
918								if r#additional_type_property.is_some() {
919									return Err(<A::Error as de::Error>::duplicate_field(
920										"additionalType",
921									));
922								}
923								r#additional_type_property = Some({
924									struct DeserializeWith(Vec<AdditionalTypeProperty>);
925									impl<'de> Deserialize<'de> for DeserializeWith {
926										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
927										where
928											D: Deserializer<'de>,
929										{
930											Ok(DeserializeWith(serde_with::As::<
931												serde_with::OneOrMany<serde_with::Same>,
932											>::deserialize(deserializer)?))
933										}
934									}
935									match map.next_value::<DeserializeWith>() {
936										Ok(deserialize_with) => deserialize_with.0,
937										Err(err) => {
938											return Err(err);
939										}
940									}
941								});
942							}
943							Field::AlternateName => {
944								if r#alternate_name_property.is_some() {
945									return Err(<A::Error as de::Error>::duplicate_field(
946										"alternateName",
947									));
948								}
949								r#alternate_name_property = Some({
950									struct DeserializeWith(Vec<AlternateNameProperty>);
951									impl<'de> Deserialize<'de> for DeserializeWith {
952										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
953										where
954											D: Deserializer<'de>,
955										{
956											Ok(DeserializeWith(serde_with::As::<
957												serde_with::OneOrMany<serde_with::Same>,
958											>::deserialize(deserializer)?))
959										}
960									}
961									match map.next_value::<DeserializeWith>() {
962										Ok(deserialize_with) => deserialize_with.0,
963										Err(err) => {
964											return Err(err);
965										}
966									}
967								});
968							}
969							Field::Description => {
970								if r#description_property.is_some() {
971									return Err(<A::Error as de::Error>::duplicate_field(
972										"description",
973									));
974								}
975								r#description_property = Some({
976									struct DeserializeWith(Vec<DescriptionProperty>);
977									impl<'de> Deserialize<'de> for DeserializeWith {
978										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
979										where
980											D: Deserializer<'de>,
981										{
982											Ok(DeserializeWith(serde_with::As::<
983												serde_with::OneOrMany<serde_with::Same>,
984											>::deserialize(deserializer)?))
985										}
986									}
987									match map.next_value::<DeserializeWith>() {
988										Ok(deserialize_with) => deserialize_with.0,
989										Err(err) => {
990											return Err(err);
991										}
992									}
993								});
994							}
995							Field::DisambiguatingDescription => {
996								if r#disambiguating_description_property.is_some() {
997									return Err(<A::Error as de::Error>::duplicate_field(
998										"disambiguatingDescription",
999									));
1000								}
1001								r#disambiguating_description_property = Some({
1002									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1003									impl<'de> Deserialize<'de> for DeserializeWith {
1004										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1005										where
1006											D: Deserializer<'de>,
1007										{
1008											Ok(DeserializeWith(serde_with::As::<
1009												serde_with::OneOrMany<serde_with::Same>,
1010											>::deserialize(deserializer)?))
1011										}
1012									}
1013									match map.next_value::<DeserializeWith>() {
1014										Ok(deserialize_with) => deserialize_with.0,
1015										Err(err) => {
1016											return Err(err);
1017										}
1018									}
1019								});
1020							}
1021							Field::Identifier => {
1022								if r#identifier_property.is_some() {
1023									return Err(<A::Error as de::Error>::duplicate_field(
1024										"identifier",
1025									));
1026								}
1027								r#identifier_property = Some({
1028									struct DeserializeWith(Vec<IdentifierProperty>);
1029									impl<'de> Deserialize<'de> for DeserializeWith {
1030										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1031										where
1032											D: Deserializer<'de>,
1033										{
1034											Ok(DeserializeWith(serde_with::As::<
1035												serde_with::OneOrMany<serde_with::Same>,
1036											>::deserialize(deserializer)?))
1037										}
1038									}
1039									match map.next_value::<DeserializeWith>() {
1040										Ok(deserialize_with) => deserialize_with.0,
1041										Err(err) => {
1042											return Err(err);
1043										}
1044									}
1045								});
1046							}
1047							Field::Image => {
1048								if r#image_property.is_some() {
1049									return Err(<A::Error as de::Error>::duplicate_field("image"));
1050								}
1051								r#image_property = Some({
1052									struct DeserializeWith(Vec<ImageProperty>);
1053									impl<'de> Deserialize<'de> for DeserializeWith {
1054										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1055										where
1056											D: Deserializer<'de>,
1057										{
1058											Ok(DeserializeWith(serde_with::As::<
1059												serde_with::OneOrMany<serde_with::Same>,
1060											>::deserialize(deserializer)?))
1061										}
1062									}
1063									match map.next_value::<DeserializeWith>() {
1064										Ok(deserialize_with) => deserialize_with.0,
1065										Err(err) => {
1066											return Err(err);
1067										}
1068									}
1069								});
1070							}
1071							Field::MainEntityOfPage => {
1072								if r#main_entity_of_page_property.is_some() {
1073									return Err(<A::Error as de::Error>::duplicate_field(
1074										"mainEntityOfPage",
1075									));
1076								}
1077								r#main_entity_of_page_property = Some({
1078									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1079									impl<'de> Deserialize<'de> for DeserializeWith {
1080										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1081										where
1082											D: Deserializer<'de>,
1083										{
1084											Ok(DeserializeWith(serde_with::As::<
1085												serde_with::OneOrMany<serde_with::Same>,
1086											>::deserialize(deserializer)?))
1087										}
1088									}
1089									match map.next_value::<DeserializeWith>() {
1090										Ok(deserialize_with) => deserialize_with.0,
1091										Err(err) => {
1092											return Err(err);
1093										}
1094									}
1095								});
1096							}
1097							Field::Name => {
1098								if r#name_property.is_some() {
1099									return Err(<A::Error as de::Error>::duplicate_field("name"));
1100								}
1101								r#name_property = Some({
1102									struct DeserializeWith(Vec<NameProperty>);
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::PotentialAction => {
1122								if r#potential_action_property.is_some() {
1123									return Err(<A::Error as de::Error>::duplicate_field(
1124										"potentialAction",
1125									));
1126								}
1127								r#potential_action_property = Some({
1128									struct DeserializeWith(Vec<PotentialActionProperty>);
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::SameAs => {
1148								if r#same_as_property.is_some() {
1149									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1150								}
1151								r#same_as_property = Some({
1152									struct DeserializeWith(Vec<SameAsProperty>);
1153									impl<'de> Deserialize<'de> for DeserializeWith {
1154										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1155										where
1156											D: Deserializer<'de>,
1157										{
1158											Ok(DeserializeWith(serde_with::As::<
1159												serde_with::OneOrMany<serde_with::Same>,
1160											>::deserialize(deserializer)?))
1161										}
1162									}
1163									match map.next_value::<DeserializeWith>() {
1164										Ok(deserialize_with) => deserialize_with.0,
1165										Err(err) => {
1166											return Err(err);
1167										}
1168									}
1169								});
1170							}
1171							Field::SubjectOf => {
1172								if r#subject_of_property.is_some() {
1173									return Err(<A::Error as de::Error>::duplicate_field(
1174										"subjectOf",
1175									));
1176								}
1177								r#subject_of_property = Some({
1178									struct DeserializeWith(Vec<SubjectOfProperty>);
1179									impl<'de> Deserialize<'de> for DeserializeWith {
1180										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1181										where
1182											D: Deserializer<'de>,
1183										{
1184											Ok(DeserializeWith(serde_with::As::<
1185												serde_with::OneOrMany<serde_with::Same>,
1186											>::deserialize(deserializer)?))
1187										}
1188									}
1189									match map.next_value::<DeserializeWith>() {
1190										Ok(deserialize_with) => deserialize_with.0,
1191										Err(err) => {
1192											return Err(err);
1193										}
1194									}
1195								});
1196							}
1197							Field::Url => {
1198								if r#url_property.is_some() {
1199									return Err(<A::Error as de::Error>::duplicate_field("url"));
1200								}
1201								r#url_property = Some({
1202									struct DeserializeWith(Vec<UrlProperty>);
1203									impl<'de> Deserialize<'de> for DeserializeWith {
1204										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1205										where
1206											D: Deserializer<'de>,
1207										{
1208											Ok(DeserializeWith(serde_with::As::<
1209												serde_with::OneOrMany<serde_with::Same>,
1210											>::deserialize(deserializer)?))
1211										}
1212									}
1213									match map.next_value::<DeserializeWith>() {
1214										Ok(deserialize_with) => deserialize_with.0,
1215										Err(err) => {
1216											return Err(err);
1217										}
1218									}
1219								});
1220							}
1221							Field::Ignore => {
1222								let _ = map.next_value::<de::IgnoredAny>()?;
1223							}
1224						}
1225					}
1226					Ok(MedicalIntangible {
1227						r#code: r#code_property.unwrap_or_default(),
1228						r#funding: r#funding_property.unwrap_or_default(),
1229						r#guideline: r#guideline_property.unwrap_or_default(),
1230						r#legal_status: r#legal_status_property.unwrap_or_default(),
1231						r#medicine_system: r#medicine_system_property.unwrap_or_default(),
1232						r#recognizing_authority: r#recognizing_authority_property
1233							.unwrap_or_default(),
1234						r#relevant_specialty: r#relevant_specialty_property.unwrap_or_default(),
1235						r#study: r#study_property.unwrap_or_default(),
1236						r#additional_type: r#additional_type_property.unwrap_or_default(),
1237						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1238						r#description: r#description_property.unwrap_or_default(),
1239						r#disambiguating_description: r#disambiguating_description_property
1240							.unwrap_or_default(),
1241						r#identifier: r#identifier_property.unwrap_or_default(),
1242						r#image: r#image_property.unwrap_or_default(),
1243						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1244						r#name: r#name_property.unwrap_or_default(),
1245						r#potential_action: r#potential_action_property.unwrap_or_default(),
1246						r#same_as: r#same_as_property.unwrap_or_default(),
1247						r#subject_of: r#subject_of_property.unwrap_or_default(),
1248						r#url: r#url_property.unwrap_or_default(),
1249					})
1250				}
1251			}
1252			const FIELDS: &[&str] = &[
1253				"code",
1254				"funding",
1255				"guideline",
1256				"legalStatus",
1257				"medicineSystem",
1258				"recognizingAuthority",
1259				"relevantSpecialty",
1260				"study",
1261				"additionalType",
1262				"alternateName",
1263				"description",
1264				"disambiguatingDescription",
1265				"identifier",
1266				"image",
1267				"mainEntityOfPage",
1268				"name",
1269				"potentialAction",
1270				"sameAs",
1271				"subjectOf",
1272				"url",
1273			];
1274			deserializer.deserialize_struct("MedicalIntangible", FIELDS, ClassVisitor)
1275		}
1276	}
1277}
schema_org_types/schemas/classes/medical_intangible.rs

schema_org_types/schemas/classes/
medical_intangible.rs
