schema_org_types/schemas/classes/
medical_guideline.rs

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

schema_org_types/schemas/classes/
medical_guideline.rs
