schema_org_types/schemas/classes/
parent_audience.rs

1use super::*;
2/// <https://schema.org/ParentAudience>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct ParentAudience {
6	/// <https://schema.org/childMaxAge>
7	pub r#child_max_age: Vec<ChildMaxAgeProperty>,
8	/// <https://schema.org/childMinAge>
9	pub r#child_min_age: Vec<ChildMinAgeProperty>,
10	/// <https://schema.org/audienceType>
11	pub r#audience_type: Vec<AudienceTypeProperty>,
12	/// <https://schema.org/geographicArea>
13	pub r#geographic_area: Vec<GeographicAreaProperty>,
14	/// <https://schema.org/healthCondition>
15	pub r#health_condition: Vec<HealthConditionProperty>,
16	/// <https://schema.org/requiredGender>
17	pub r#required_gender: Vec<RequiredGenderProperty>,
18	/// <https://schema.org/requiredMaxAge>
19	pub r#required_max_age: Vec<RequiredMaxAgeProperty>,
20	/// <https://schema.org/requiredMinAge>
21	pub r#required_min_age: Vec<RequiredMinAgeProperty>,
22	/// <https://schema.org/suggestedAge>
23	pub r#suggested_age: Vec<SuggestedAgeProperty>,
24	/// <https://schema.org/suggestedGender>
25	pub r#suggested_gender: Vec<SuggestedGenderProperty>,
26	/// <https://schema.org/suggestedMaxAge>
27	pub r#suggested_max_age: Vec<SuggestedMaxAgeProperty>,
28	/// <https://schema.org/suggestedMeasurement>
29	pub r#suggested_measurement: Vec<SuggestedMeasurementProperty>,
30	/// <https://schema.org/suggestedMinAge>
31	pub r#suggested_min_age: Vec<SuggestedMinAgeProperty>,
32	/// <https://schema.org/additionalType>
33	pub r#additional_type: Vec<AdditionalTypeProperty>,
34	/// <https://schema.org/alternateName>
35	pub r#alternate_name: Vec<AlternateNameProperty>,
36	/// <https://schema.org/description>
37	pub r#description: Vec<DescriptionProperty>,
38	/// <https://schema.org/disambiguatingDescription>
39	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
40	/// <https://schema.org/identifier>
41	pub r#identifier: Vec<IdentifierProperty>,
42	/// <https://schema.org/image>
43	pub r#image: Vec<ImageProperty>,
44	/// <https://schema.org/mainEntityOfPage>
45	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
46	/// <https://schema.org/name>
47	pub r#name: Vec<NameProperty>,
48	/// <https://schema.org/potentialAction>
49	pub r#potential_action: Vec<PotentialActionProperty>,
50	/// <https://schema.org/sameAs>
51	pub r#same_as: Vec<SameAsProperty>,
52	/// <https://schema.org/subjectOf>
53	pub r#subject_of: Vec<SubjectOfProperty>,
54	/// <https://schema.org/url>
55	pub r#url: Vec<UrlProperty>,
56}
57/// This trait is for properties from <https://schema.org/ParentAudience>.
58pub trait ParentAudienceTrait {
59	/// Get <https://schema.org/childMaxAge> from [`Self`] as borrowed slice.
60	fn get_child_max_age(&self) -> &[ChildMaxAgeProperty];
61	/// Take <https://schema.org/childMaxAge> from [`Self`] as owned vector.
62	fn take_child_max_age(&mut self) -> Vec<ChildMaxAgeProperty>;
63	/// Get <https://schema.org/childMinAge> from [`Self`] as borrowed slice.
64	fn get_child_min_age(&self) -> &[ChildMinAgeProperty];
65	/// Take <https://schema.org/childMinAge> from [`Self`] as owned vector.
66	fn take_child_min_age(&mut self) -> Vec<ChildMinAgeProperty>;
67}
68impl ParentAudienceTrait for ParentAudience {
69	fn get_child_max_age(&self) -> &[ChildMaxAgeProperty] {
70		self.r#child_max_age.as_slice()
71	}
72	fn take_child_max_age(&mut self) -> Vec<ChildMaxAgeProperty> {
73		std::mem::take(&mut self.r#child_max_age)
74	}
75	fn get_child_min_age(&self) -> &[ChildMinAgeProperty] {
76		self.r#child_min_age.as_slice()
77	}
78	fn take_child_min_age(&mut self) -> Vec<ChildMinAgeProperty> {
79		std::mem::take(&mut self.r#child_min_age)
80	}
81}
82impl AudienceTrait for ParentAudience {
83	fn get_audience_type(&self) -> &[AudienceTypeProperty] {
84		self.r#audience_type.as_slice()
85	}
86	fn take_audience_type(&mut self) -> Vec<AudienceTypeProperty> {
87		std::mem::take(&mut self.r#audience_type)
88	}
89	fn get_geographic_area(&self) -> &[GeographicAreaProperty] {
90		self.r#geographic_area.as_slice()
91	}
92	fn take_geographic_area(&mut self) -> Vec<GeographicAreaProperty> {
93		std::mem::take(&mut self.r#geographic_area)
94	}
95}
96impl PeopleAudienceTrait for ParentAudience {
97	fn get_health_condition(&self) -> &[HealthConditionProperty] {
98		self.r#health_condition.as_slice()
99	}
100	fn take_health_condition(&mut self) -> Vec<HealthConditionProperty> {
101		std::mem::take(&mut self.r#health_condition)
102	}
103	fn get_required_gender(&self) -> &[RequiredGenderProperty] {
104		self.r#required_gender.as_slice()
105	}
106	fn take_required_gender(&mut self) -> Vec<RequiredGenderProperty> {
107		std::mem::take(&mut self.r#required_gender)
108	}
109	fn get_required_max_age(&self) -> &[RequiredMaxAgeProperty] {
110		self.r#required_max_age.as_slice()
111	}
112	fn take_required_max_age(&mut self) -> Vec<RequiredMaxAgeProperty> {
113		std::mem::take(&mut self.r#required_max_age)
114	}
115	fn get_required_min_age(&self) -> &[RequiredMinAgeProperty] {
116		self.r#required_min_age.as_slice()
117	}
118	fn take_required_min_age(&mut self) -> Vec<RequiredMinAgeProperty> {
119		std::mem::take(&mut self.r#required_min_age)
120	}
121	fn get_suggested_age(&self) -> &[SuggestedAgeProperty] {
122		self.r#suggested_age.as_slice()
123	}
124	fn take_suggested_age(&mut self) -> Vec<SuggestedAgeProperty> {
125		std::mem::take(&mut self.r#suggested_age)
126	}
127	fn get_suggested_gender(&self) -> &[SuggestedGenderProperty] {
128		self.r#suggested_gender.as_slice()
129	}
130	fn take_suggested_gender(&mut self) -> Vec<SuggestedGenderProperty> {
131		std::mem::take(&mut self.r#suggested_gender)
132	}
133	fn get_suggested_max_age(&self) -> &[SuggestedMaxAgeProperty] {
134		self.r#suggested_max_age.as_slice()
135	}
136	fn take_suggested_max_age(&mut self) -> Vec<SuggestedMaxAgeProperty> {
137		std::mem::take(&mut self.r#suggested_max_age)
138	}
139	fn get_suggested_measurement(&self) -> &[SuggestedMeasurementProperty] {
140		self.r#suggested_measurement.as_slice()
141	}
142	fn take_suggested_measurement(&mut self) -> Vec<SuggestedMeasurementProperty> {
143		std::mem::take(&mut self.r#suggested_measurement)
144	}
145	fn get_suggested_min_age(&self) -> &[SuggestedMinAgeProperty] {
146		self.r#suggested_min_age.as_slice()
147	}
148	fn take_suggested_min_age(&mut self) -> Vec<SuggestedMinAgeProperty> {
149		std::mem::take(&mut self.r#suggested_min_age)
150	}
151}
152impl ThingTrait for ParentAudience {
153	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
154		self.r#additional_type.as_slice()
155	}
156	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
157		std::mem::take(&mut self.r#additional_type)
158	}
159	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
160		self.r#alternate_name.as_slice()
161	}
162	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
163		std::mem::take(&mut self.r#alternate_name)
164	}
165	fn get_description(&self) -> &[DescriptionProperty] {
166		self.r#description.as_slice()
167	}
168	fn take_description(&mut self) -> Vec<DescriptionProperty> {
169		std::mem::take(&mut self.r#description)
170	}
171	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
172		self.r#disambiguating_description.as_slice()
173	}
174	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
175		std::mem::take(&mut self.r#disambiguating_description)
176	}
177	fn get_identifier(&self) -> &[IdentifierProperty] {
178		self.r#identifier.as_slice()
179	}
180	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
181		std::mem::take(&mut self.r#identifier)
182	}
183	fn get_image(&self) -> &[ImageProperty] {
184		self.r#image.as_slice()
185	}
186	fn take_image(&mut self) -> Vec<ImageProperty> {
187		std::mem::take(&mut self.r#image)
188	}
189	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
190		self.r#main_entity_of_page.as_slice()
191	}
192	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
193		std::mem::take(&mut self.r#main_entity_of_page)
194	}
195	fn get_name(&self) -> &[NameProperty] {
196		self.r#name.as_slice()
197	}
198	fn take_name(&mut self) -> Vec<NameProperty> {
199		std::mem::take(&mut self.r#name)
200	}
201	fn get_potential_action(&self) -> &[PotentialActionProperty] {
202		self.r#potential_action.as_slice()
203	}
204	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
205		std::mem::take(&mut self.r#potential_action)
206	}
207	fn get_same_as(&self) -> &[SameAsProperty] {
208		self.r#same_as.as_slice()
209	}
210	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
211		std::mem::take(&mut self.r#same_as)
212	}
213	fn get_subject_of(&self) -> &[SubjectOfProperty] {
214		self.r#subject_of.as_slice()
215	}
216	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
217		std::mem::take(&mut self.r#subject_of)
218	}
219	fn get_url(&self) -> &[UrlProperty] {
220		self.r#url.as_slice()
221	}
222	fn take_url(&mut self) -> Vec<UrlProperty> {
223		std::mem::take(&mut self.r#url)
224	}
225}
226#[cfg(feature = "serde")]
227mod serde {
228	use std::{fmt, fmt::Formatter};
229
230	use ::serde::{
231		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
232	};
233
234	use super::*;
235	impl Serialize for ParentAudience {
236		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
237		where
238			S: Serializer,
239		{
240			let len: usize = [
241				!Vec::is_empty(&self.r#child_max_age) as usize,
242				!Vec::is_empty(&self.r#child_min_age) as usize,
243				!Vec::is_empty(&self.r#audience_type) as usize,
244				!Vec::is_empty(&self.r#geographic_area) as usize,
245				!Vec::is_empty(&self.r#health_condition) as usize,
246				!Vec::is_empty(&self.r#required_gender) as usize,
247				!Vec::is_empty(&self.r#required_max_age) as usize,
248				!Vec::is_empty(&self.r#required_min_age) as usize,
249				!Vec::is_empty(&self.r#suggested_age) as usize,
250				!Vec::is_empty(&self.r#suggested_gender) as usize,
251				!Vec::is_empty(&self.r#suggested_max_age) as usize,
252				!Vec::is_empty(&self.r#suggested_measurement) as usize,
253				!Vec::is_empty(&self.r#suggested_min_age) as usize,
254				!Vec::is_empty(&self.r#additional_type) as usize,
255				!Vec::is_empty(&self.r#alternate_name) as usize,
256				!Vec::is_empty(&self.r#description) as usize,
257				!Vec::is_empty(&self.r#disambiguating_description) as usize,
258				!Vec::is_empty(&self.r#identifier) as usize,
259				!Vec::is_empty(&self.r#image) as usize,
260				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
261				!Vec::is_empty(&self.r#name) as usize,
262				!Vec::is_empty(&self.r#potential_action) as usize,
263				!Vec::is_empty(&self.r#same_as) as usize,
264				!Vec::is_empty(&self.r#subject_of) as usize,
265				!Vec::is_empty(&self.r#url) as usize,
266			]
267			.iter()
268			.sum();
269			let mut serialize_struct =
270				Serializer::serialize_struct(serializer, "ParentAudience", len)?;
271			if !Vec::is_empty(&self.r#child_max_age) {
272				serialize_struct.serialize_field("childMaxAge", {
273					struct SerializeWith<'a>(&'a Vec<ChildMaxAgeProperty>);
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#child_max_age)
285				})?;
286			} else {
287				serialize_struct.skip_field("childMaxAge")?;
288			}
289			if !Vec::is_empty(&self.r#child_min_age) {
290				serialize_struct.serialize_field("childMinAge", {
291					struct SerializeWith<'a>(&'a Vec<ChildMinAgeProperty>);
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#child_min_age)
303				})?;
304			} else {
305				serialize_struct.skip_field("childMinAge")?;
306			}
307			if !Vec::is_empty(&self.r#audience_type) {
308				serialize_struct.serialize_field("audienceType", {
309					struct SerializeWith<'a>(&'a Vec<AudienceTypeProperty>);
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#audience_type)
321				})?;
322			} else {
323				serialize_struct.skip_field("audienceType")?;
324			}
325			if !Vec::is_empty(&self.r#geographic_area) {
326				serialize_struct.serialize_field("geographicArea", {
327					struct SerializeWith<'a>(&'a Vec<GeographicAreaProperty>);
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#geographic_area)
339				})?;
340			} else {
341				serialize_struct.skip_field("geographicArea")?;
342			}
343			if !Vec::is_empty(&self.r#health_condition) {
344				serialize_struct.serialize_field("healthCondition", {
345					struct SerializeWith<'a>(&'a Vec<HealthConditionProperty>);
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#health_condition)
357				})?;
358			} else {
359				serialize_struct.skip_field("healthCondition")?;
360			}
361			if !Vec::is_empty(&self.r#required_gender) {
362				serialize_struct.serialize_field("requiredGender", {
363					struct SerializeWith<'a>(&'a Vec<RequiredGenderProperty>);
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#required_gender)
375				})?;
376			} else {
377				serialize_struct.skip_field("requiredGender")?;
378			}
379			if !Vec::is_empty(&self.r#required_max_age) {
380				serialize_struct.serialize_field("requiredMaxAge", {
381					struct SerializeWith<'a>(&'a Vec<RequiredMaxAgeProperty>);
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#required_max_age)
393				})?;
394			} else {
395				serialize_struct.skip_field("requiredMaxAge")?;
396			}
397			if !Vec::is_empty(&self.r#required_min_age) {
398				serialize_struct.serialize_field("requiredMinAge", {
399					struct SerializeWith<'a>(&'a Vec<RequiredMinAgeProperty>);
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#required_min_age)
411				})?;
412			} else {
413				serialize_struct.skip_field("requiredMinAge")?;
414			}
415			if !Vec::is_empty(&self.r#suggested_age) {
416				serialize_struct.serialize_field("suggestedAge", {
417					struct SerializeWith<'a>(&'a Vec<SuggestedAgeProperty>);
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#suggested_age)
429				})?;
430			} else {
431				serialize_struct.skip_field("suggestedAge")?;
432			}
433			if !Vec::is_empty(&self.r#suggested_gender) {
434				serialize_struct.serialize_field("suggestedGender", {
435					struct SerializeWith<'a>(&'a Vec<SuggestedGenderProperty>);
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#suggested_gender)
447				})?;
448			} else {
449				serialize_struct.skip_field("suggestedGender")?;
450			}
451			if !Vec::is_empty(&self.r#suggested_max_age) {
452				serialize_struct.serialize_field("suggestedMaxAge", {
453					struct SerializeWith<'a>(&'a Vec<SuggestedMaxAgeProperty>);
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#suggested_max_age)
465				})?;
466			} else {
467				serialize_struct.skip_field("suggestedMaxAge")?;
468			}
469			if !Vec::is_empty(&self.r#suggested_measurement) {
470				serialize_struct.serialize_field("suggestedMeasurement", {
471					struct SerializeWith<'a>(&'a Vec<SuggestedMeasurementProperty>);
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#suggested_measurement)
483				})?;
484			} else {
485				serialize_struct.skip_field("suggestedMeasurement")?;
486			}
487			if !Vec::is_empty(&self.r#suggested_min_age) {
488				serialize_struct.serialize_field("suggestedMinAge", {
489					struct SerializeWith<'a>(&'a Vec<SuggestedMinAgeProperty>);
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#suggested_min_age)
501				})?;
502			} else {
503				serialize_struct.skip_field("suggestedMinAge")?;
504			}
505			if !Vec::is_empty(&self.r#additional_type) {
506				serialize_struct.serialize_field("additionalType", {
507					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
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#additional_type)
519				})?;
520			} else {
521				serialize_struct.skip_field("additionalType")?;
522			}
523			if !Vec::is_empty(&self.r#alternate_name) {
524				serialize_struct.serialize_field("alternateName", {
525					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
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#alternate_name)
537				})?;
538			} else {
539				serialize_struct.skip_field("alternateName")?;
540			}
541			if !Vec::is_empty(&self.r#description) {
542				serialize_struct.serialize_field("description", {
543					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
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#description)
555				})?;
556			} else {
557				serialize_struct.skip_field("description")?;
558			}
559			if !Vec::is_empty(&self.r#disambiguating_description) {
560				serialize_struct.serialize_field("disambiguatingDescription", {
561					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
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#disambiguating_description)
573				})?;
574			} else {
575				serialize_struct.skip_field("disambiguatingDescription")?;
576			}
577			if !Vec::is_empty(&self.r#identifier) {
578				serialize_struct.serialize_field("identifier", {
579					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
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#identifier)
591				})?;
592			} else {
593				serialize_struct.skip_field("identifier")?;
594			}
595			if !Vec::is_empty(&self.r#image) {
596				serialize_struct.serialize_field("image", {
597					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
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#image)
609				})?;
610			} else {
611				serialize_struct.skip_field("image")?;
612			}
613			if !Vec::is_empty(&self.r#main_entity_of_page) {
614				serialize_struct.serialize_field("mainEntityOfPage", {
615					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
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#main_entity_of_page)
627				})?;
628			} else {
629				serialize_struct.skip_field("mainEntityOfPage")?;
630			}
631			if !Vec::is_empty(&self.r#name) {
632				serialize_struct.serialize_field("name", {
633					struct SerializeWith<'a>(&'a Vec<NameProperty>);
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#name)
645				})?;
646			} else {
647				serialize_struct.skip_field("name")?;
648			}
649			if !Vec::is_empty(&self.r#potential_action) {
650				serialize_struct.serialize_field("potentialAction", {
651					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
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#potential_action)
663				})?;
664			} else {
665				serialize_struct.skip_field("potentialAction")?;
666			}
667			if !Vec::is_empty(&self.r#same_as) {
668				serialize_struct.serialize_field("sameAs", {
669					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
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#same_as)
681				})?;
682			} else {
683				serialize_struct.skip_field("sameAs")?;
684			}
685			if !Vec::is_empty(&self.r#subject_of) {
686				serialize_struct.serialize_field("subjectOf", {
687					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
688					impl<'a> Serialize for SerializeWith<'a> {
689						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
690						where
691							S: Serializer,
692						{
693							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
694								self.0, serializer,
695							)
696						}
697					}
698					&SerializeWith(&self.r#subject_of)
699				})?;
700			} else {
701				serialize_struct.skip_field("subjectOf")?;
702			}
703			if !Vec::is_empty(&self.r#url) {
704				serialize_struct.serialize_field("url", {
705					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
706					impl<'a> Serialize for SerializeWith<'a> {
707						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
708						where
709							S: Serializer,
710						{
711							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
712								self.0, serializer,
713							)
714						}
715					}
716					&SerializeWith(&self.r#url)
717				})?;
718			} else {
719				serialize_struct.skip_field("url")?;
720			}
721			serialize_struct.end()
722		}
723	}
724	impl<'de> Deserialize<'de> for ParentAudience {
725		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
726		where
727			D: Deserializer<'de>,
728		{
729			enum Field {
730				ChildMaxAge,
731				ChildMinAge,
732				AudienceType,
733				GeographicArea,
734				HealthCondition,
735				RequiredGender,
736				RequiredMaxAge,
737				RequiredMinAge,
738				SuggestedAge,
739				SuggestedGender,
740				SuggestedMaxAge,
741				SuggestedMeasurement,
742				SuggestedMinAge,
743				AdditionalType,
744				AlternateName,
745				Description,
746				DisambiguatingDescription,
747				Identifier,
748				Image,
749				MainEntityOfPage,
750				Name,
751				PotentialAction,
752				SameAs,
753				SubjectOf,
754				Url,
755				Ignore,
756			}
757			struct FieldVisitor;
758			impl<'de> Visitor<'de> for FieldVisitor {
759				type Value = Field;
760				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
761					formatter.write_str("field identifier")
762				}
763				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
764				where
765					E: de::Error,
766				{
767					match value {
768						"childMaxAge" => Ok(Field::ChildMaxAge),
769						"childMinAge" => Ok(Field::ChildMinAge),
770						"audienceType" => Ok(Field::AudienceType),
771						"geographicArea" => Ok(Field::GeographicArea),
772						"healthCondition" => Ok(Field::HealthCondition),
773						"requiredGender" => Ok(Field::RequiredGender),
774						"requiredMaxAge" => Ok(Field::RequiredMaxAge),
775						"requiredMinAge" => Ok(Field::RequiredMinAge),
776						"suggestedAge" => Ok(Field::SuggestedAge),
777						"suggestedGender" => Ok(Field::SuggestedGender),
778						"suggestedMaxAge" => Ok(Field::SuggestedMaxAge),
779						"suggestedMeasurement" => Ok(Field::SuggestedMeasurement),
780						"suggestedMinAge" => Ok(Field::SuggestedMinAge),
781						"additionalType" => Ok(Field::AdditionalType),
782						"alternateName" => Ok(Field::AlternateName),
783						"description" => Ok(Field::Description),
784						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
785						"identifier" => Ok(Field::Identifier),
786						"image" => Ok(Field::Image),
787						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
788						"name" => Ok(Field::Name),
789						"potentialAction" => Ok(Field::PotentialAction),
790						"sameAs" => Ok(Field::SameAs),
791						"subjectOf" => Ok(Field::SubjectOf),
792						"url" => Ok(Field::Url),
793						"id" | "type" => Ok(Field::Ignore),
794						_ => Err(de::Error::unknown_field(value, FIELDS)),
795					}
796				}
797				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
798				where
799					E: de::Error,
800				{
801					match value {
802						b"childMaxAge" => Ok(Field::ChildMaxAge),
803						b"childMinAge" => Ok(Field::ChildMinAge),
804						b"audienceType" => Ok(Field::AudienceType),
805						b"geographicArea" => Ok(Field::GeographicArea),
806						b"healthCondition" => Ok(Field::HealthCondition),
807						b"requiredGender" => Ok(Field::RequiredGender),
808						b"requiredMaxAge" => Ok(Field::RequiredMaxAge),
809						b"requiredMinAge" => Ok(Field::RequiredMinAge),
810						b"suggestedAge" => Ok(Field::SuggestedAge),
811						b"suggestedGender" => Ok(Field::SuggestedGender),
812						b"suggestedMaxAge" => Ok(Field::SuggestedMaxAge),
813						b"suggestedMeasurement" => Ok(Field::SuggestedMeasurement),
814						b"suggestedMinAge" => Ok(Field::SuggestedMinAge),
815						b"additionalType" => Ok(Field::AdditionalType),
816						b"alternateName" => Ok(Field::AlternateName),
817						b"description" => Ok(Field::Description),
818						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
819						b"identifier" => Ok(Field::Identifier),
820						b"image" => Ok(Field::Image),
821						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
822						b"name" => Ok(Field::Name),
823						b"potentialAction" => Ok(Field::PotentialAction),
824						b"sameAs" => Ok(Field::SameAs),
825						b"subjectOf" => Ok(Field::SubjectOf),
826						b"url" => Ok(Field::Url),
827						b"id" | b"type" => Ok(Field::Ignore),
828						_ => {
829							let value = &String::from_utf8_lossy(value);
830							Err(de::Error::unknown_field(value, FIELDS))
831						}
832					}
833				}
834			}
835			impl<'de> Deserialize<'de> for Field {
836				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
837				where
838					D: Deserializer<'de>,
839				{
840					deserializer.deserialize_identifier(FieldVisitor)
841				}
842			}
843			struct ClassVisitor;
844			impl<'de> Visitor<'de> for ClassVisitor {
845				type Value = ParentAudience;
846				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
847					formatter.write_str("schema.org schema ParentAudience")
848				}
849				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
850				where
851					A: de::MapAccess<'de>,
852				{
853					let mut r#child_max_age_property = None;
854					let mut r#child_min_age_property = None;
855					let mut r#audience_type_property = None;
856					let mut r#geographic_area_property = None;
857					let mut r#health_condition_property = None;
858					let mut r#required_gender_property = None;
859					let mut r#required_max_age_property = None;
860					let mut r#required_min_age_property = None;
861					let mut r#suggested_age_property = None;
862					let mut r#suggested_gender_property = None;
863					let mut r#suggested_max_age_property = None;
864					let mut r#suggested_measurement_property = None;
865					let mut r#suggested_min_age_property = None;
866					let mut r#additional_type_property = None;
867					let mut r#alternate_name_property = None;
868					let mut r#description_property = None;
869					let mut r#disambiguating_description_property = None;
870					let mut r#identifier_property = None;
871					let mut r#image_property = None;
872					let mut r#main_entity_of_page_property = None;
873					let mut r#name_property = None;
874					let mut r#potential_action_property = None;
875					let mut r#same_as_property = None;
876					let mut r#subject_of_property = None;
877					let mut r#url_property = None;
878					while let Some(key) = map.next_key::<Field>()? {
879						match key {
880							Field::ChildMaxAge => {
881								if r#child_max_age_property.is_some() {
882									return Err(<A::Error as de::Error>::duplicate_field(
883										"childMaxAge",
884									));
885								}
886								r#child_max_age_property = Some({
887									struct DeserializeWith(Vec<ChildMaxAgeProperty>);
888									impl<'de> Deserialize<'de> for DeserializeWith {
889										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
890										where
891											D: Deserializer<'de>,
892										{
893											Ok(DeserializeWith(serde_with::As::<
894												serde_with::OneOrMany<serde_with::Same>,
895											>::deserialize(deserializer)?))
896										}
897									}
898									match map.next_value::<DeserializeWith>() {
899										Ok(deserialize_with) => deserialize_with.0,
900										Err(err) => {
901											return Err(err);
902										}
903									}
904								});
905							}
906							Field::ChildMinAge => {
907								if r#child_min_age_property.is_some() {
908									return Err(<A::Error as de::Error>::duplicate_field(
909										"childMinAge",
910									));
911								}
912								r#child_min_age_property = Some({
913									struct DeserializeWith(Vec<ChildMinAgeProperty>);
914									impl<'de> Deserialize<'de> for DeserializeWith {
915										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
916										where
917											D: Deserializer<'de>,
918										{
919											Ok(DeserializeWith(serde_with::As::<
920												serde_with::OneOrMany<serde_with::Same>,
921											>::deserialize(deserializer)?))
922										}
923									}
924									match map.next_value::<DeserializeWith>() {
925										Ok(deserialize_with) => deserialize_with.0,
926										Err(err) => {
927											return Err(err);
928										}
929									}
930								});
931							}
932							Field::AudienceType => {
933								if r#audience_type_property.is_some() {
934									return Err(<A::Error as de::Error>::duplicate_field(
935										"audienceType",
936									));
937								}
938								r#audience_type_property = Some({
939									struct DeserializeWith(Vec<AudienceTypeProperty>);
940									impl<'de> Deserialize<'de> for DeserializeWith {
941										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
942										where
943											D: Deserializer<'de>,
944										{
945											Ok(DeserializeWith(serde_with::As::<
946												serde_with::OneOrMany<serde_with::Same>,
947											>::deserialize(deserializer)?))
948										}
949									}
950									match map.next_value::<DeserializeWith>() {
951										Ok(deserialize_with) => deserialize_with.0,
952										Err(err) => {
953											return Err(err);
954										}
955									}
956								});
957							}
958							Field::GeographicArea => {
959								if r#geographic_area_property.is_some() {
960									return Err(<A::Error as de::Error>::duplicate_field(
961										"geographicArea",
962									));
963								}
964								r#geographic_area_property = Some({
965									struct DeserializeWith(Vec<GeographicAreaProperty>);
966									impl<'de> Deserialize<'de> for DeserializeWith {
967										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
968										where
969											D: Deserializer<'de>,
970										{
971											Ok(DeserializeWith(serde_with::As::<
972												serde_with::OneOrMany<serde_with::Same>,
973											>::deserialize(deserializer)?))
974										}
975									}
976									match map.next_value::<DeserializeWith>() {
977										Ok(deserialize_with) => deserialize_with.0,
978										Err(err) => {
979											return Err(err);
980										}
981									}
982								});
983							}
984							Field::HealthCondition => {
985								if r#health_condition_property.is_some() {
986									return Err(<A::Error as de::Error>::duplicate_field(
987										"healthCondition",
988									));
989								}
990								r#health_condition_property = Some({
991									struct DeserializeWith(Vec<HealthConditionProperty>);
992									impl<'de> Deserialize<'de> for DeserializeWith {
993										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
994										where
995											D: Deserializer<'de>,
996										{
997											Ok(DeserializeWith(serde_with::As::<
998												serde_with::OneOrMany<serde_with::Same>,
999											>::deserialize(deserializer)?))
1000										}
1001									}
1002									match map.next_value::<DeserializeWith>() {
1003										Ok(deserialize_with) => deserialize_with.0,
1004										Err(err) => {
1005											return Err(err);
1006										}
1007									}
1008								});
1009							}
1010							Field::RequiredGender => {
1011								if r#required_gender_property.is_some() {
1012									return Err(<A::Error as de::Error>::duplicate_field(
1013										"requiredGender",
1014									));
1015								}
1016								r#required_gender_property = Some({
1017									struct DeserializeWith(Vec<RequiredGenderProperty>);
1018									impl<'de> Deserialize<'de> for DeserializeWith {
1019										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1020										where
1021											D: Deserializer<'de>,
1022										{
1023											Ok(DeserializeWith(serde_with::As::<
1024												serde_with::OneOrMany<serde_with::Same>,
1025											>::deserialize(deserializer)?))
1026										}
1027									}
1028									match map.next_value::<DeserializeWith>() {
1029										Ok(deserialize_with) => deserialize_with.0,
1030										Err(err) => {
1031											return Err(err);
1032										}
1033									}
1034								});
1035							}
1036							Field::RequiredMaxAge => {
1037								if r#required_max_age_property.is_some() {
1038									return Err(<A::Error as de::Error>::duplicate_field(
1039										"requiredMaxAge",
1040									));
1041								}
1042								r#required_max_age_property = Some({
1043									struct DeserializeWith(Vec<RequiredMaxAgeProperty>);
1044									impl<'de> Deserialize<'de> for DeserializeWith {
1045										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1046										where
1047											D: Deserializer<'de>,
1048										{
1049											Ok(DeserializeWith(serde_with::As::<
1050												serde_with::OneOrMany<serde_with::Same>,
1051											>::deserialize(deserializer)?))
1052										}
1053									}
1054									match map.next_value::<DeserializeWith>() {
1055										Ok(deserialize_with) => deserialize_with.0,
1056										Err(err) => {
1057											return Err(err);
1058										}
1059									}
1060								});
1061							}
1062							Field::RequiredMinAge => {
1063								if r#required_min_age_property.is_some() {
1064									return Err(<A::Error as de::Error>::duplicate_field(
1065										"requiredMinAge",
1066									));
1067								}
1068								r#required_min_age_property = Some({
1069									struct DeserializeWith(Vec<RequiredMinAgeProperty>);
1070									impl<'de> Deserialize<'de> for DeserializeWith {
1071										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1072										where
1073											D: Deserializer<'de>,
1074										{
1075											Ok(DeserializeWith(serde_with::As::<
1076												serde_with::OneOrMany<serde_with::Same>,
1077											>::deserialize(deserializer)?))
1078										}
1079									}
1080									match map.next_value::<DeserializeWith>() {
1081										Ok(deserialize_with) => deserialize_with.0,
1082										Err(err) => {
1083											return Err(err);
1084										}
1085									}
1086								});
1087							}
1088							Field::SuggestedAge => {
1089								if r#suggested_age_property.is_some() {
1090									return Err(<A::Error as de::Error>::duplicate_field(
1091										"suggestedAge",
1092									));
1093								}
1094								r#suggested_age_property = Some({
1095									struct DeserializeWith(Vec<SuggestedAgeProperty>);
1096									impl<'de> Deserialize<'de> for DeserializeWith {
1097										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1098										where
1099											D: Deserializer<'de>,
1100										{
1101											Ok(DeserializeWith(serde_with::As::<
1102												serde_with::OneOrMany<serde_with::Same>,
1103											>::deserialize(deserializer)?))
1104										}
1105									}
1106									match map.next_value::<DeserializeWith>() {
1107										Ok(deserialize_with) => deserialize_with.0,
1108										Err(err) => {
1109											return Err(err);
1110										}
1111									}
1112								});
1113							}
1114							Field::SuggestedGender => {
1115								if r#suggested_gender_property.is_some() {
1116									return Err(<A::Error as de::Error>::duplicate_field(
1117										"suggestedGender",
1118									));
1119								}
1120								r#suggested_gender_property = Some({
1121									struct DeserializeWith(Vec<SuggestedGenderProperty>);
1122									impl<'de> Deserialize<'de> for DeserializeWith {
1123										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1124										where
1125											D: Deserializer<'de>,
1126										{
1127											Ok(DeserializeWith(serde_with::As::<
1128												serde_with::OneOrMany<serde_with::Same>,
1129											>::deserialize(deserializer)?))
1130										}
1131									}
1132									match map.next_value::<DeserializeWith>() {
1133										Ok(deserialize_with) => deserialize_with.0,
1134										Err(err) => {
1135											return Err(err);
1136										}
1137									}
1138								});
1139							}
1140							Field::SuggestedMaxAge => {
1141								if r#suggested_max_age_property.is_some() {
1142									return Err(<A::Error as de::Error>::duplicate_field(
1143										"suggestedMaxAge",
1144									));
1145								}
1146								r#suggested_max_age_property = Some({
1147									struct DeserializeWith(Vec<SuggestedMaxAgeProperty>);
1148									impl<'de> Deserialize<'de> for DeserializeWith {
1149										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1150										where
1151											D: Deserializer<'de>,
1152										{
1153											Ok(DeserializeWith(serde_with::As::<
1154												serde_with::OneOrMany<serde_with::Same>,
1155											>::deserialize(deserializer)?))
1156										}
1157									}
1158									match map.next_value::<DeserializeWith>() {
1159										Ok(deserialize_with) => deserialize_with.0,
1160										Err(err) => {
1161											return Err(err);
1162										}
1163									}
1164								});
1165							}
1166							Field::SuggestedMeasurement => {
1167								if r#suggested_measurement_property.is_some() {
1168									return Err(<A::Error as de::Error>::duplicate_field(
1169										"suggestedMeasurement",
1170									));
1171								}
1172								r#suggested_measurement_property = Some({
1173									struct DeserializeWith(Vec<SuggestedMeasurementProperty>);
1174									impl<'de> Deserialize<'de> for DeserializeWith {
1175										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1176										where
1177											D: Deserializer<'de>,
1178										{
1179											Ok(DeserializeWith(serde_with::As::<
1180												serde_with::OneOrMany<serde_with::Same>,
1181											>::deserialize(deserializer)?))
1182										}
1183									}
1184									match map.next_value::<DeserializeWith>() {
1185										Ok(deserialize_with) => deserialize_with.0,
1186										Err(err) => {
1187											return Err(err);
1188										}
1189									}
1190								});
1191							}
1192							Field::SuggestedMinAge => {
1193								if r#suggested_min_age_property.is_some() {
1194									return Err(<A::Error as de::Error>::duplicate_field(
1195										"suggestedMinAge",
1196									));
1197								}
1198								r#suggested_min_age_property = Some({
1199									struct DeserializeWith(Vec<SuggestedMinAgeProperty>);
1200									impl<'de> Deserialize<'de> for DeserializeWith {
1201										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1202										where
1203											D: Deserializer<'de>,
1204										{
1205											Ok(DeserializeWith(serde_with::As::<
1206												serde_with::OneOrMany<serde_with::Same>,
1207											>::deserialize(deserializer)?))
1208										}
1209									}
1210									match map.next_value::<DeserializeWith>() {
1211										Ok(deserialize_with) => deserialize_with.0,
1212										Err(err) => {
1213											return Err(err);
1214										}
1215									}
1216								});
1217							}
1218							Field::AdditionalType => {
1219								if r#additional_type_property.is_some() {
1220									return Err(<A::Error as de::Error>::duplicate_field(
1221										"additionalType",
1222									));
1223								}
1224								r#additional_type_property = Some({
1225									struct DeserializeWith(Vec<AdditionalTypeProperty>);
1226									impl<'de> Deserialize<'de> for DeserializeWith {
1227										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1228										where
1229											D: Deserializer<'de>,
1230										{
1231											Ok(DeserializeWith(serde_with::As::<
1232												serde_with::OneOrMany<serde_with::Same>,
1233											>::deserialize(deserializer)?))
1234										}
1235									}
1236									match map.next_value::<DeserializeWith>() {
1237										Ok(deserialize_with) => deserialize_with.0,
1238										Err(err) => {
1239											return Err(err);
1240										}
1241									}
1242								});
1243							}
1244							Field::AlternateName => {
1245								if r#alternate_name_property.is_some() {
1246									return Err(<A::Error as de::Error>::duplicate_field(
1247										"alternateName",
1248									));
1249								}
1250								r#alternate_name_property = Some({
1251									struct DeserializeWith(Vec<AlternateNameProperty>);
1252									impl<'de> Deserialize<'de> for DeserializeWith {
1253										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1254										where
1255											D: Deserializer<'de>,
1256										{
1257											Ok(DeserializeWith(serde_with::As::<
1258												serde_with::OneOrMany<serde_with::Same>,
1259											>::deserialize(deserializer)?))
1260										}
1261									}
1262									match map.next_value::<DeserializeWith>() {
1263										Ok(deserialize_with) => deserialize_with.0,
1264										Err(err) => {
1265											return Err(err);
1266										}
1267									}
1268								});
1269							}
1270							Field::Description => {
1271								if r#description_property.is_some() {
1272									return Err(<A::Error as de::Error>::duplicate_field(
1273										"description",
1274									));
1275								}
1276								r#description_property = Some({
1277									struct DeserializeWith(Vec<DescriptionProperty>);
1278									impl<'de> Deserialize<'de> for DeserializeWith {
1279										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1280										where
1281											D: Deserializer<'de>,
1282										{
1283											Ok(DeserializeWith(serde_with::As::<
1284												serde_with::OneOrMany<serde_with::Same>,
1285											>::deserialize(deserializer)?))
1286										}
1287									}
1288									match map.next_value::<DeserializeWith>() {
1289										Ok(deserialize_with) => deserialize_with.0,
1290										Err(err) => {
1291											return Err(err);
1292										}
1293									}
1294								});
1295							}
1296							Field::DisambiguatingDescription => {
1297								if r#disambiguating_description_property.is_some() {
1298									return Err(<A::Error as de::Error>::duplicate_field(
1299										"disambiguatingDescription",
1300									));
1301								}
1302								r#disambiguating_description_property = Some({
1303									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1304									impl<'de> Deserialize<'de> for DeserializeWith {
1305										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1306										where
1307											D: Deserializer<'de>,
1308										{
1309											Ok(DeserializeWith(serde_with::As::<
1310												serde_with::OneOrMany<serde_with::Same>,
1311											>::deserialize(deserializer)?))
1312										}
1313									}
1314									match map.next_value::<DeserializeWith>() {
1315										Ok(deserialize_with) => deserialize_with.0,
1316										Err(err) => {
1317											return Err(err);
1318										}
1319									}
1320								});
1321							}
1322							Field::Identifier => {
1323								if r#identifier_property.is_some() {
1324									return Err(<A::Error as de::Error>::duplicate_field(
1325										"identifier",
1326									));
1327								}
1328								r#identifier_property = Some({
1329									struct DeserializeWith(Vec<IdentifierProperty>);
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::Image => {
1349								if r#image_property.is_some() {
1350									return Err(<A::Error as de::Error>::duplicate_field("image"));
1351								}
1352								r#image_property = Some({
1353									struct DeserializeWith(Vec<ImageProperty>);
1354									impl<'de> Deserialize<'de> for DeserializeWith {
1355										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1356										where
1357											D: Deserializer<'de>,
1358										{
1359											Ok(DeserializeWith(serde_with::As::<
1360												serde_with::OneOrMany<serde_with::Same>,
1361											>::deserialize(deserializer)?))
1362										}
1363									}
1364									match map.next_value::<DeserializeWith>() {
1365										Ok(deserialize_with) => deserialize_with.0,
1366										Err(err) => {
1367											return Err(err);
1368										}
1369									}
1370								});
1371							}
1372							Field::MainEntityOfPage => {
1373								if r#main_entity_of_page_property.is_some() {
1374									return Err(<A::Error as de::Error>::duplicate_field(
1375										"mainEntityOfPage",
1376									));
1377								}
1378								r#main_entity_of_page_property = Some({
1379									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
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::Name => {
1399								if r#name_property.is_some() {
1400									return Err(<A::Error as de::Error>::duplicate_field("name"));
1401								}
1402								r#name_property = Some({
1403									struct DeserializeWith(Vec<NameProperty>);
1404									impl<'de> Deserialize<'de> for DeserializeWith {
1405										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1406										where
1407											D: Deserializer<'de>,
1408										{
1409											Ok(DeserializeWith(serde_with::As::<
1410												serde_with::OneOrMany<serde_with::Same>,
1411											>::deserialize(deserializer)?))
1412										}
1413									}
1414									match map.next_value::<DeserializeWith>() {
1415										Ok(deserialize_with) => deserialize_with.0,
1416										Err(err) => {
1417											return Err(err);
1418										}
1419									}
1420								});
1421							}
1422							Field::PotentialAction => {
1423								if r#potential_action_property.is_some() {
1424									return Err(<A::Error as de::Error>::duplicate_field(
1425										"potentialAction",
1426									));
1427								}
1428								r#potential_action_property = Some({
1429									struct DeserializeWith(Vec<PotentialActionProperty>);
1430									impl<'de> Deserialize<'de> for DeserializeWith {
1431										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1432										where
1433											D: Deserializer<'de>,
1434										{
1435											Ok(DeserializeWith(serde_with::As::<
1436												serde_with::OneOrMany<serde_with::Same>,
1437											>::deserialize(deserializer)?))
1438										}
1439									}
1440									match map.next_value::<DeserializeWith>() {
1441										Ok(deserialize_with) => deserialize_with.0,
1442										Err(err) => {
1443											return Err(err);
1444										}
1445									}
1446								});
1447							}
1448							Field::SameAs => {
1449								if r#same_as_property.is_some() {
1450									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1451								}
1452								r#same_as_property = Some({
1453									struct DeserializeWith(Vec<SameAsProperty>);
1454									impl<'de> Deserialize<'de> for DeserializeWith {
1455										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1456										where
1457											D: Deserializer<'de>,
1458										{
1459											Ok(DeserializeWith(serde_with::As::<
1460												serde_with::OneOrMany<serde_with::Same>,
1461											>::deserialize(deserializer)?))
1462										}
1463									}
1464									match map.next_value::<DeserializeWith>() {
1465										Ok(deserialize_with) => deserialize_with.0,
1466										Err(err) => {
1467											return Err(err);
1468										}
1469									}
1470								});
1471							}
1472							Field::SubjectOf => {
1473								if r#subject_of_property.is_some() {
1474									return Err(<A::Error as de::Error>::duplicate_field(
1475										"subjectOf",
1476									));
1477								}
1478								r#subject_of_property = Some({
1479									struct DeserializeWith(Vec<SubjectOfProperty>);
1480									impl<'de> Deserialize<'de> for DeserializeWith {
1481										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1482										where
1483											D: Deserializer<'de>,
1484										{
1485											Ok(DeserializeWith(serde_with::As::<
1486												serde_with::OneOrMany<serde_with::Same>,
1487											>::deserialize(deserializer)?))
1488										}
1489									}
1490									match map.next_value::<DeserializeWith>() {
1491										Ok(deserialize_with) => deserialize_with.0,
1492										Err(err) => {
1493											return Err(err);
1494										}
1495									}
1496								});
1497							}
1498							Field::Url => {
1499								if r#url_property.is_some() {
1500									return Err(<A::Error as de::Error>::duplicate_field("url"));
1501								}
1502								r#url_property = Some({
1503									struct DeserializeWith(Vec<UrlProperty>);
1504									impl<'de> Deserialize<'de> for DeserializeWith {
1505										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1506										where
1507											D: Deserializer<'de>,
1508										{
1509											Ok(DeserializeWith(serde_with::As::<
1510												serde_with::OneOrMany<serde_with::Same>,
1511											>::deserialize(deserializer)?))
1512										}
1513									}
1514									match map.next_value::<DeserializeWith>() {
1515										Ok(deserialize_with) => deserialize_with.0,
1516										Err(err) => {
1517											return Err(err);
1518										}
1519									}
1520								});
1521							}
1522							Field::Ignore => {
1523								let _ = map.next_value::<de::IgnoredAny>()?;
1524							}
1525						}
1526					}
1527					Ok(ParentAudience {
1528						r#child_max_age: r#child_max_age_property.unwrap_or_default(),
1529						r#child_min_age: r#child_min_age_property.unwrap_or_default(),
1530						r#audience_type: r#audience_type_property.unwrap_or_default(),
1531						r#geographic_area: r#geographic_area_property.unwrap_or_default(),
1532						r#health_condition: r#health_condition_property.unwrap_or_default(),
1533						r#required_gender: r#required_gender_property.unwrap_or_default(),
1534						r#required_max_age: r#required_max_age_property.unwrap_or_default(),
1535						r#required_min_age: r#required_min_age_property.unwrap_or_default(),
1536						r#suggested_age: r#suggested_age_property.unwrap_or_default(),
1537						r#suggested_gender: r#suggested_gender_property.unwrap_or_default(),
1538						r#suggested_max_age: r#suggested_max_age_property.unwrap_or_default(),
1539						r#suggested_measurement: r#suggested_measurement_property
1540							.unwrap_or_default(),
1541						r#suggested_min_age: r#suggested_min_age_property.unwrap_or_default(),
1542						r#additional_type: r#additional_type_property.unwrap_or_default(),
1543						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1544						r#description: r#description_property.unwrap_or_default(),
1545						r#disambiguating_description: r#disambiguating_description_property
1546							.unwrap_or_default(),
1547						r#identifier: r#identifier_property.unwrap_or_default(),
1548						r#image: r#image_property.unwrap_or_default(),
1549						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1550						r#name: r#name_property.unwrap_or_default(),
1551						r#potential_action: r#potential_action_property.unwrap_or_default(),
1552						r#same_as: r#same_as_property.unwrap_or_default(),
1553						r#subject_of: r#subject_of_property.unwrap_or_default(),
1554						r#url: r#url_property.unwrap_or_default(),
1555					})
1556				}
1557			}
1558			const FIELDS: &[&str] = &[
1559				"childMaxAge",
1560				"childMinAge",
1561				"audienceType",
1562				"geographicArea",
1563				"healthCondition",
1564				"requiredGender",
1565				"requiredMaxAge",
1566				"requiredMinAge",
1567				"suggestedAge",
1568				"suggestedGender",
1569				"suggestedMaxAge",
1570				"suggestedMeasurement",
1571				"suggestedMinAge",
1572				"additionalType",
1573				"alternateName",
1574				"description",
1575				"disambiguatingDescription",
1576				"identifier",
1577				"image",
1578				"mainEntityOfPage",
1579				"name",
1580				"potentialAction",
1581				"sameAs",
1582				"subjectOf",
1583				"url",
1584			];
1585			deserializer.deserialize_struct("ParentAudience", FIELDS, ClassVisitor)
1586		}
1587	}
1588}
schema_org_types/schemas/classes/parent_audience.rs

schema_org_types/schemas/classes/
parent_audience.rs
