schema_org_types/schemas/classes/
medical_audience.rs

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

schema_org_types/schemas/classes/
medical_audience.rs
