schema_org_types/schemas/classes/
blood_test.rs

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

schema_org_types/schemas/classes/
blood_test.rs
