schema_org_types/schemas/classes/
maximum_dose_schedule.rs

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

schema_org_types/schemas/classes/
maximum_dose_schedule.rs
