schema_org_types/schemas/classes/
medical_procedure.rs

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

schema_org_types/schemas/classes/
medical_procedure.rs
