schema_org_types/schemas/classes/
size_specification.rs

1use super::*;
2/// <https://schema.org/SizeSpecification>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct SizeSpecification {
6	/// <https://schema.org/hasMeasurement>
7	pub r#has_measurement: Vec<HasMeasurementProperty>,
8	/// <https://schema.org/sizeGroup>
9	pub r#size_group: Vec<SizeGroupProperty>,
10	/// <https://schema.org/sizeSystem>
11	pub r#size_system: Vec<SizeSystemProperty>,
12	/// <https://schema.org/suggestedAge>
13	pub r#suggested_age: Vec<SuggestedAgeProperty>,
14	/// <https://schema.org/suggestedGender>
15	pub r#suggested_gender: Vec<SuggestedGenderProperty>,
16	/// <https://schema.org/suggestedMeasurement>
17	pub r#suggested_measurement: Vec<SuggestedMeasurementProperty>,
18	/// <https://schema.org/supersededBy>
19	pub r#superseded_by: Vec<SupersededByProperty>,
20	/// <https://schema.org/additionalProperty>
21	pub r#additional_property: Vec<AdditionalPropertyProperty>,
22	/// <https://schema.org/equal>
23	pub r#equal: Vec<EqualProperty>,
24	/// <https://schema.org/greater>
25	pub r#greater: Vec<GreaterProperty>,
26	/// <https://schema.org/greaterOrEqual>
27	pub r#greater_or_equal: Vec<GreaterOrEqualProperty>,
28	/// <https://schema.org/lesser>
29	pub r#lesser: Vec<LesserProperty>,
30	/// <https://schema.org/lesserOrEqual>
31	pub r#lesser_or_equal: Vec<LesserOrEqualProperty>,
32	/// <https://schema.org/nonEqual>
33	pub r#non_equal: Vec<NonEqualProperty>,
34	/// <https://schema.org/valueReference>
35	pub r#value_reference: Vec<ValueReferenceProperty>,
36	/// <https://schema.org/additionalType>
37	pub r#additional_type: Vec<AdditionalTypeProperty>,
38	/// <https://schema.org/alternateName>
39	pub r#alternate_name: Vec<AlternateNameProperty>,
40	/// <https://schema.org/description>
41	pub r#description: Vec<DescriptionProperty>,
42	/// <https://schema.org/disambiguatingDescription>
43	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
44	/// <https://schema.org/identifier>
45	pub r#identifier: Vec<IdentifierProperty>,
46	/// <https://schema.org/image>
47	pub r#image: Vec<ImageProperty>,
48	/// <https://schema.org/mainEntityOfPage>
49	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
50	/// <https://schema.org/name>
51	pub r#name: Vec<NameProperty>,
52	/// <https://schema.org/potentialAction>
53	pub r#potential_action: Vec<PotentialActionProperty>,
54	/// <https://schema.org/sameAs>
55	pub r#same_as: Vec<SameAsProperty>,
56	/// <https://schema.org/subjectOf>
57	pub r#subject_of: Vec<SubjectOfProperty>,
58	/// <https://schema.org/url>
59	pub r#url: Vec<UrlProperty>,
60}
61/// This trait is for properties from <https://schema.org/SizeSpecification>.
62pub trait SizeSpecificationTrait {
63	/// Get <https://schema.org/hasMeasurement> from [`Self`] as borrowed slice.
64	fn get_has_measurement(&self) -> &[HasMeasurementProperty];
65	/// Take <https://schema.org/hasMeasurement> from [`Self`] as owned vector.
66	fn take_has_measurement(&mut self) -> Vec<HasMeasurementProperty>;
67	/// Get <https://schema.org/sizeGroup> from [`Self`] as borrowed slice.
68	fn get_size_group(&self) -> &[SizeGroupProperty];
69	/// Take <https://schema.org/sizeGroup> from [`Self`] as owned vector.
70	fn take_size_group(&mut self) -> Vec<SizeGroupProperty>;
71	/// Get <https://schema.org/sizeSystem> from [`Self`] as borrowed slice.
72	fn get_size_system(&self) -> &[SizeSystemProperty];
73	/// Take <https://schema.org/sizeSystem> from [`Self`] as owned vector.
74	fn take_size_system(&mut self) -> Vec<SizeSystemProperty>;
75	/// Get <https://schema.org/suggestedAge> from [`Self`] as borrowed slice.
76	fn get_suggested_age(&self) -> &[SuggestedAgeProperty];
77	/// Take <https://schema.org/suggestedAge> from [`Self`] as owned vector.
78	fn take_suggested_age(&mut self) -> Vec<SuggestedAgeProperty>;
79	/// Get <https://schema.org/suggestedGender> from [`Self`] as borrowed slice.
80	fn get_suggested_gender(&self) -> &[SuggestedGenderProperty];
81	/// Take <https://schema.org/suggestedGender> from [`Self`] as owned vector.
82	fn take_suggested_gender(&mut self) -> Vec<SuggestedGenderProperty>;
83	/// Get <https://schema.org/suggestedMeasurement> from [`Self`] as borrowed slice.
84	fn get_suggested_measurement(&self) -> &[SuggestedMeasurementProperty];
85	/// Take <https://schema.org/suggestedMeasurement> from [`Self`] as owned vector.
86	fn take_suggested_measurement(&mut self) -> Vec<SuggestedMeasurementProperty>;
87}
88impl SizeSpecificationTrait for SizeSpecification {
89	fn get_has_measurement(&self) -> &[HasMeasurementProperty] {
90		self.r#has_measurement.as_slice()
91	}
92	fn take_has_measurement(&mut self) -> Vec<HasMeasurementProperty> {
93		std::mem::take(&mut self.r#has_measurement)
94	}
95	fn get_size_group(&self) -> &[SizeGroupProperty] {
96		self.r#size_group.as_slice()
97	}
98	fn take_size_group(&mut self) -> Vec<SizeGroupProperty> {
99		std::mem::take(&mut self.r#size_group)
100	}
101	fn get_size_system(&self) -> &[SizeSystemProperty] {
102		self.r#size_system.as_slice()
103	}
104	fn take_size_system(&mut self) -> Vec<SizeSystemProperty> {
105		std::mem::take(&mut self.r#size_system)
106	}
107	fn get_suggested_age(&self) -> &[SuggestedAgeProperty] {
108		self.r#suggested_age.as_slice()
109	}
110	fn take_suggested_age(&mut self) -> Vec<SuggestedAgeProperty> {
111		std::mem::take(&mut self.r#suggested_age)
112	}
113	fn get_suggested_gender(&self) -> &[SuggestedGenderProperty] {
114		self.r#suggested_gender.as_slice()
115	}
116	fn take_suggested_gender(&mut self) -> Vec<SuggestedGenderProperty> {
117		std::mem::take(&mut self.r#suggested_gender)
118	}
119	fn get_suggested_measurement(&self) -> &[SuggestedMeasurementProperty] {
120		self.r#suggested_measurement.as_slice()
121	}
122	fn take_suggested_measurement(&mut self) -> Vec<SuggestedMeasurementProperty> {
123		std::mem::take(&mut self.r#suggested_measurement)
124	}
125}
126impl EnumerationTrait for SizeSpecification {
127	fn get_superseded_by(&self) -> &[SupersededByProperty] {
128		self.r#superseded_by.as_slice()
129	}
130	fn take_superseded_by(&mut self) -> Vec<SupersededByProperty> {
131		std::mem::take(&mut self.r#superseded_by)
132	}
133}
134impl QualitativeValueTrait for SizeSpecification {
135	fn get_additional_property(&self) -> &[AdditionalPropertyProperty] {
136		self.r#additional_property.as_slice()
137	}
138	fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty> {
139		std::mem::take(&mut self.r#additional_property)
140	}
141	fn get_equal(&self) -> &[EqualProperty] {
142		self.r#equal.as_slice()
143	}
144	fn take_equal(&mut self) -> Vec<EqualProperty> {
145		std::mem::take(&mut self.r#equal)
146	}
147	fn get_greater(&self) -> &[GreaterProperty] {
148		self.r#greater.as_slice()
149	}
150	fn take_greater(&mut self) -> Vec<GreaterProperty> {
151		std::mem::take(&mut self.r#greater)
152	}
153	fn get_greater_or_equal(&self) -> &[GreaterOrEqualProperty] {
154		self.r#greater_or_equal.as_slice()
155	}
156	fn take_greater_or_equal(&mut self) -> Vec<GreaterOrEqualProperty> {
157		std::mem::take(&mut self.r#greater_or_equal)
158	}
159	fn get_lesser(&self) -> &[LesserProperty] {
160		self.r#lesser.as_slice()
161	}
162	fn take_lesser(&mut self) -> Vec<LesserProperty> {
163		std::mem::take(&mut self.r#lesser)
164	}
165	fn get_lesser_or_equal(&self) -> &[LesserOrEqualProperty] {
166		self.r#lesser_or_equal.as_slice()
167	}
168	fn take_lesser_or_equal(&mut self) -> Vec<LesserOrEqualProperty> {
169		std::mem::take(&mut self.r#lesser_or_equal)
170	}
171	fn get_non_equal(&self) -> &[NonEqualProperty] {
172		self.r#non_equal.as_slice()
173	}
174	fn take_non_equal(&mut self) -> Vec<NonEqualProperty> {
175		std::mem::take(&mut self.r#non_equal)
176	}
177	fn get_value_reference(&self) -> &[ValueReferenceProperty] {
178		self.r#value_reference.as_slice()
179	}
180	fn take_value_reference(&mut self) -> Vec<ValueReferenceProperty> {
181		std::mem::take(&mut self.r#value_reference)
182	}
183}
184impl ThingTrait for SizeSpecification {
185	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
186		self.r#additional_type.as_slice()
187	}
188	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
189		std::mem::take(&mut self.r#additional_type)
190	}
191	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
192		self.r#alternate_name.as_slice()
193	}
194	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
195		std::mem::take(&mut self.r#alternate_name)
196	}
197	fn get_description(&self) -> &[DescriptionProperty] {
198		self.r#description.as_slice()
199	}
200	fn take_description(&mut self) -> Vec<DescriptionProperty> {
201		std::mem::take(&mut self.r#description)
202	}
203	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
204		self.r#disambiguating_description.as_slice()
205	}
206	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
207		std::mem::take(&mut self.r#disambiguating_description)
208	}
209	fn get_identifier(&self) -> &[IdentifierProperty] {
210		self.r#identifier.as_slice()
211	}
212	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
213		std::mem::take(&mut self.r#identifier)
214	}
215	fn get_image(&self) -> &[ImageProperty] {
216		self.r#image.as_slice()
217	}
218	fn take_image(&mut self) -> Vec<ImageProperty> {
219		std::mem::take(&mut self.r#image)
220	}
221	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
222		self.r#main_entity_of_page.as_slice()
223	}
224	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
225		std::mem::take(&mut self.r#main_entity_of_page)
226	}
227	fn get_name(&self) -> &[NameProperty] {
228		self.r#name.as_slice()
229	}
230	fn take_name(&mut self) -> Vec<NameProperty> {
231		std::mem::take(&mut self.r#name)
232	}
233	fn get_potential_action(&self) -> &[PotentialActionProperty] {
234		self.r#potential_action.as_slice()
235	}
236	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
237		std::mem::take(&mut self.r#potential_action)
238	}
239	fn get_same_as(&self) -> &[SameAsProperty] {
240		self.r#same_as.as_slice()
241	}
242	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
243		std::mem::take(&mut self.r#same_as)
244	}
245	fn get_subject_of(&self) -> &[SubjectOfProperty] {
246		self.r#subject_of.as_slice()
247	}
248	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
249		std::mem::take(&mut self.r#subject_of)
250	}
251	fn get_url(&self) -> &[UrlProperty] {
252		self.r#url.as_slice()
253	}
254	fn take_url(&mut self) -> Vec<UrlProperty> {
255		std::mem::take(&mut self.r#url)
256	}
257}
258#[cfg(feature = "serde")]
259mod serde {
260	use std::{fmt, fmt::Formatter};
261
262	use ::serde::{
263		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
264	};
265
266	use super::*;
267	impl Serialize for SizeSpecification {
268		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
269		where
270			S: Serializer,
271		{
272			let len: usize = [
273				!Vec::is_empty(&self.r#has_measurement) as usize,
274				!Vec::is_empty(&self.r#size_group) as usize,
275				!Vec::is_empty(&self.r#size_system) as usize,
276				!Vec::is_empty(&self.r#suggested_age) as usize,
277				!Vec::is_empty(&self.r#suggested_gender) as usize,
278				!Vec::is_empty(&self.r#suggested_measurement) as usize,
279				!Vec::is_empty(&self.r#superseded_by) as usize,
280				!Vec::is_empty(&self.r#additional_property) as usize,
281				!Vec::is_empty(&self.r#equal) as usize,
282				!Vec::is_empty(&self.r#greater) as usize,
283				!Vec::is_empty(&self.r#greater_or_equal) as usize,
284				!Vec::is_empty(&self.r#lesser) as usize,
285				!Vec::is_empty(&self.r#lesser_or_equal) as usize,
286				!Vec::is_empty(&self.r#non_equal) as usize,
287				!Vec::is_empty(&self.r#value_reference) as usize,
288				!Vec::is_empty(&self.r#additional_type) as usize,
289				!Vec::is_empty(&self.r#alternate_name) as usize,
290				!Vec::is_empty(&self.r#description) as usize,
291				!Vec::is_empty(&self.r#disambiguating_description) as usize,
292				!Vec::is_empty(&self.r#identifier) as usize,
293				!Vec::is_empty(&self.r#image) as usize,
294				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
295				!Vec::is_empty(&self.r#name) as usize,
296				!Vec::is_empty(&self.r#potential_action) as usize,
297				!Vec::is_empty(&self.r#same_as) as usize,
298				!Vec::is_empty(&self.r#subject_of) as usize,
299				!Vec::is_empty(&self.r#url) as usize,
300			]
301			.iter()
302			.sum();
303			let mut serialize_struct =
304				Serializer::serialize_struct(serializer, "SizeSpecification", len)?;
305			if !Vec::is_empty(&self.r#has_measurement) {
306				serialize_struct.serialize_field("hasMeasurement", {
307					struct SerializeWith<'a>(&'a Vec<HasMeasurementProperty>);
308					impl<'a> Serialize for SerializeWith<'a> {
309						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
310						where
311							S: Serializer,
312						{
313							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
314								self.0, serializer,
315							)
316						}
317					}
318					&SerializeWith(&self.r#has_measurement)
319				})?;
320			} else {
321				serialize_struct.skip_field("hasMeasurement")?;
322			}
323			if !Vec::is_empty(&self.r#size_group) {
324				serialize_struct.serialize_field("sizeGroup", {
325					struct SerializeWith<'a>(&'a Vec<SizeGroupProperty>);
326					impl<'a> Serialize for SerializeWith<'a> {
327						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
328						where
329							S: Serializer,
330						{
331							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
332								self.0, serializer,
333							)
334						}
335					}
336					&SerializeWith(&self.r#size_group)
337				})?;
338			} else {
339				serialize_struct.skip_field("sizeGroup")?;
340			}
341			if !Vec::is_empty(&self.r#size_system) {
342				serialize_struct.serialize_field("sizeSystem", {
343					struct SerializeWith<'a>(&'a Vec<SizeSystemProperty>);
344					impl<'a> Serialize for SerializeWith<'a> {
345						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
346						where
347							S: Serializer,
348						{
349							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
350								self.0, serializer,
351							)
352						}
353					}
354					&SerializeWith(&self.r#size_system)
355				})?;
356			} else {
357				serialize_struct.skip_field("sizeSystem")?;
358			}
359			if !Vec::is_empty(&self.r#suggested_age) {
360				serialize_struct.serialize_field("suggestedAge", {
361					struct SerializeWith<'a>(&'a Vec<SuggestedAgeProperty>);
362					impl<'a> Serialize for SerializeWith<'a> {
363						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
364						where
365							S: Serializer,
366						{
367							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
368								self.0, serializer,
369							)
370						}
371					}
372					&SerializeWith(&self.r#suggested_age)
373				})?;
374			} else {
375				serialize_struct.skip_field("suggestedAge")?;
376			}
377			if !Vec::is_empty(&self.r#suggested_gender) {
378				serialize_struct.serialize_field("suggestedGender", {
379					struct SerializeWith<'a>(&'a Vec<SuggestedGenderProperty>);
380					impl<'a> Serialize for SerializeWith<'a> {
381						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
382						where
383							S: Serializer,
384						{
385							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
386								self.0, serializer,
387							)
388						}
389					}
390					&SerializeWith(&self.r#suggested_gender)
391				})?;
392			} else {
393				serialize_struct.skip_field("suggestedGender")?;
394			}
395			if !Vec::is_empty(&self.r#suggested_measurement) {
396				serialize_struct.serialize_field("suggestedMeasurement", {
397					struct SerializeWith<'a>(&'a Vec<SuggestedMeasurementProperty>);
398					impl<'a> Serialize for SerializeWith<'a> {
399						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
400						where
401							S: Serializer,
402						{
403							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
404								self.0, serializer,
405							)
406						}
407					}
408					&SerializeWith(&self.r#suggested_measurement)
409				})?;
410			} else {
411				serialize_struct.skip_field("suggestedMeasurement")?;
412			}
413			if !Vec::is_empty(&self.r#superseded_by) {
414				serialize_struct.serialize_field("supersededBy", {
415					struct SerializeWith<'a>(&'a Vec<SupersededByProperty>);
416					impl<'a> Serialize for SerializeWith<'a> {
417						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
418						where
419							S: Serializer,
420						{
421							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
422								self.0, serializer,
423							)
424						}
425					}
426					&SerializeWith(&self.r#superseded_by)
427				})?;
428			} else {
429				serialize_struct.skip_field("supersededBy")?;
430			}
431			if !Vec::is_empty(&self.r#additional_property) {
432				serialize_struct.serialize_field("additionalProperty", {
433					struct SerializeWith<'a>(&'a Vec<AdditionalPropertyProperty>);
434					impl<'a> Serialize for SerializeWith<'a> {
435						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
436						where
437							S: Serializer,
438						{
439							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
440								self.0, serializer,
441							)
442						}
443					}
444					&SerializeWith(&self.r#additional_property)
445				})?;
446			} else {
447				serialize_struct.skip_field("additionalProperty")?;
448			}
449			if !Vec::is_empty(&self.r#equal) {
450				serialize_struct.serialize_field("equal", {
451					struct SerializeWith<'a>(&'a Vec<EqualProperty>);
452					impl<'a> Serialize for SerializeWith<'a> {
453						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
454						where
455							S: Serializer,
456						{
457							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
458								self.0, serializer,
459							)
460						}
461					}
462					&SerializeWith(&self.r#equal)
463				})?;
464			} else {
465				serialize_struct.skip_field("equal")?;
466			}
467			if !Vec::is_empty(&self.r#greater) {
468				serialize_struct.serialize_field("greater", {
469					struct SerializeWith<'a>(&'a Vec<GreaterProperty>);
470					impl<'a> Serialize for SerializeWith<'a> {
471						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
472						where
473							S: Serializer,
474						{
475							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
476								self.0, serializer,
477							)
478						}
479					}
480					&SerializeWith(&self.r#greater)
481				})?;
482			} else {
483				serialize_struct.skip_field("greater")?;
484			}
485			if !Vec::is_empty(&self.r#greater_or_equal) {
486				serialize_struct.serialize_field("greaterOrEqual", {
487					struct SerializeWith<'a>(&'a Vec<GreaterOrEqualProperty>);
488					impl<'a> Serialize for SerializeWith<'a> {
489						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
490						where
491							S: Serializer,
492						{
493							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
494								self.0, serializer,
495							)
496						}
497					}
498					&SerializeWith(&self.r#greater_or_equal)
499				})?;
500			} else {
501				serialize_struct.skip_field("greaterOrEqual")?;
502			}
503			if !Vec::is_empty(&self.r#lesser) {
504				serialize_struct.serialize_field("lesser", {
505					struct SerializeWith<'a>(&'a Vec<LesserProperty>);
506					impl<'a> Serialize for SerializeWith<'a> {
507						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
508						where
509							S: Serializer,
510						{
511							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
512								self.0, serializer,
513							)
514						}
515					}
516					&SerializeWith(&self.r#lesser)
517				})?;
518			} else {
519				serialize_struct.skip_field("lesser")?;
520			}
521			if !Vec::is_empty(&self.r#lesser_or_equal) {
522				serialize_struct.serialize_field("lesserOrEqual", {
523					struct SerializeWith<'a>(&'a Vec<LesserOrEqualProperty>);
524					impl<'a> Serialize for SerializeWith<'a> {
525						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
526						where
527							S: Serializer,
528						{
529							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
530								self.0, serializer,
531							)
532						}
533					}
534					&SerializeWith(&self.r#lesser_or_equal)
535				})?;
536			} else {
537				serialize_struct.skip_field("lesserOrEqual")?;
538			}
539			if !Vec::is_empty(&self.r#non_equal) {
540				serialize_struct.serialize_field("nonEqual", {
541					struct SerializeWith<'a>(&'a Vec<NonEqualProperty>);
542					impl<'a> Serialize for SerializeWith<'a> {
543						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
544						where
545							S: Serializer,
546						{
547							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
548								self.0, serializer,
549							)
550						}
551					}
552					&SerializeWith(&self.r#non_equal)
553				})?;
554			} else {
555				serialize_struct.skip_field("nonEqual")?;
556			}
557			if !Vec::is_empty(&self.r#value_reference) {
558				serialize_struct.serialize_field("valueReference", {
559					struct SerializeWith<'a>(&'a Vec<ValueReferenceProperty>);
560					impl<'a> Serialize for SerializeWith<'a> {
561						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
562						where
563							S: Serializer,
564						{
565							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
566								self.0, serializer,
567							)
568						}
569					}
570					&SerializeWith(&self.r#value_reference)
571				})?;
572			} else {
573				serialize_struct.skip_field("valueReference")?;
574			}
575			if !Vec::is_empty(&self.r#additional_type) {
576				serialize_struct.serialize_field("additionalType", {
577					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
578					impl<'a> Serialize for SerializeWith<'a> {
579						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
580						where
581							S: Serializer,
582						{
583							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
584								self.0, serializer,
585							)
586						}
587					}
588					&SerializeWith(&self.r#additional_type)
589				})?;
590			} else {
591				serialize_struct.skip_field("additionalType")?;
592			}
593			if !Vec::is_empty(&self.r#alternate_name) {
594				serialize_struct.serialize_field("alternateName", {
595					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
596					impl<'a> Serialize for SerializeWith<'a> {
597						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
598						where
599							S: Serializer,
600						{
601							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
602								self.0, serializer,
603							)
604						}
605					}
606					&SerializeWith(&self.r#alternate_name)
607				})?;
608			} else {
609				serialize_struct.skip_field("alternateName")?;
610			}
611			if !Vec::is_empty(&self.r#description) {
612				serialize_struct.serialize_field("description", {
613					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
614					impl<'a> Serialize for SerializeWith<'a> {
615						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
616						where
617							S: Serializer,
618						{
619							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
620								self.0, serializer,
621							)
622						}
623					}
624					&SerializeWith(&self.r#description)
625				})?;
626			} else {
627				serialize_struct.skip_field("description")?;
628			}
629			if !Vec::is_empty(&self.r#disambiguating_description) {
630				serialize_struct.serialize_field("disambiguatingDescription", {
631					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
632					impl<'a> Serialize for SerializeWith<'a> {
633						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
634						where
635							S: Serializer,
636						{
637							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
638								self.0, serializer,
639							)
640						}
641					}
642					&SerializeWith(&self.r#disambiguating_description)
643				})?;
644			} else {
645				serialize_struct.skip_field("disambiguatingDescription")?;
646			}
647			if !Vec::is_empty(&self.r#identifier) {
648				serialize_struct.serialize_field("identifier", {
649					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
650					impl<'a> Serialize for SerializeWith<'a> {
651						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
652						where
653							S: Serializer,
654						{
655							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
656								self.0, serializer,
657							)
658						}
659					}
660					&SerializeWith(&self.r#identifier)
661				})?;
662			} else {
663				serialize_struct.skip_field("identifier")?;
664			}
665			if !Vec::is_empty(&self.r#image) {
666				serialize_struct.serialize_field("image", {
667					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
668					impl<'a> Serialize for SerializeWith<'a> {
669						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
670						where
671							S: Serializer,
672						{
673							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
674								self.0, serializer,
675							)
676						}
677					}
678					&SerializeWith(&self.r#image)
679				})?;
680			} else {
681				serialize_struct.skip_field("image")?;
682			}
683			if !Vec::is_empty(&self.r#main_entity_of_page) {
684				serialize_struct.serialize_field("mainEntityOfPage", {
685					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
686					impl<'a> Serialize for SerializeWith<'a> {
687						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
688						where
689							S: Serializer,
690						{
691							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
692								self.0, serializer,
693							)
694						}
695					}
696					&SerializeWith(&self.r#main_entity_of_page)
697				})?;
698			} else {
699				serialize_struct.skip_field("mainEntityOfPage")?;
700			}
701			if !Vec::is_empty(&self.r#name) {
702				serialize_struct.serialize_field("name", {
703					struct SerializeWith<'a>(&'a Vec<NameProperty>);
704					impl<'a> Serialize for SerializeWith<'a> {
705						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
706						where
707							S: Serializer,
708						{
709							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
710								self.0, serializer,
711							)
712						}
713					}
714					&SerializeWith(&self.r#name)
715				})?;
716			} else {
717				serialize_struct.skip_field("name")?;
718			}
719			if !Vec::is_empty(&self.r#potential_action) {
720				serialize_struct.serialize_field("potentialAction", {
721					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
722					impl<'a> Serialize for SerializeWith<'a> {
723						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
724						where
725							S: Serializer,
726						{
727							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
728								self.0, serializer,
729							)
730						}
731					}
732					&SerializeWith(&self.r#potential_action)
733				})?;
734			} else {
735				serialize_struct.skip_field("potentialAction")?;
736			}
737			if !Vec::is_empty(&self.r#same_as) {
738				serialize_struct.serialize_field("sameAs", {
739					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
740					impl<'a> Serialize for SerializeWith<'a> {
741						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
742						where
743							S: Serializer,
744						{
745							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
746								self.0, serializer,
747							)
748						}
749					}
750					&SerializeWith(&self.r#same_as)
751				})?;
752			} else {
753				serialize_struct.skip_field("sameAs")?;
754			}
755			if !Vec::is_empty(&self.r#subject_of) {
756				serialize_struct.serialize_field("subjectOf", {
757					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
758					impl<'a> Serialize for SerializeWith<'a> {
759						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
760						where
761							S: Serializer,
762						{
763							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
764								self.0, serializer,
765							)
766						}
767					}
768					&SerializeWith(&self.r#subject_of)
769				})?;
770			} else {
771				serialize_struct.skip_field("subjectOf")?;
772			}
773			if !Vec::is_empty(&self.r#url) {
774				serialize_struct.serialize_field("url", {
775					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
776					impl<'a> Serialize for SerializeWith<'a> {
777						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
778						where
779							S: Serializer,
780						{
781							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
782								self.0, serializer,
783							)
784						}
785					}
786					&SerializeWith(&self.r#url)
787				})?;
788			} else {
789				serialize_struct.skip_field("url")?;
790			}
791			serialize_struct.end()
792		}
793	}
794	impl<'de> Deserialize<'de> for SizeSpecification {
795		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
796		where
797			D: Deserializer<'de>,
798		{
799			enum Field {
800				HasMeasurement,
801				SizeGroup,
802				SizeSystem,
803				SuggestedAge,
804				SuggestedGender,
805				SuggestedMeasurement,
806				SupersededBy,
807				AdditionalProperty,
808				Equal,
809				Greater,
810				GreaterOrEqual,
811				Lesser,
812				LesserOrEqual,
813				NonEqual,
814				ValueReference,
815				AdditionalType,
816				AlternateName,
817				Description,
818				DisambiguatingDescription,
819				Identifier,
820				Image,
821				MainEntityOfPage,
822				Name,
823				PotentialAction,
824				SameAs,
825				SubjectOf,
826				Url,
827				Ignore,
828			}
829			struct FieldVisitor;
830			impl<'de> Visitor<'de> for FieldVisitor {
831				type Value = Field;
832				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
833					formatter.write_str("field identifier")
834				}
835				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
836				where
837					E: de::Error,
838				{
839					match value {
840						"hasMeasurement" => Ok(Field::HasMeasurement),
841						"sizeGroup" => Ok(Field::SizeGroup),
842						"sizeSystem" => Ok(Field::SizeSystem),
843						"suggestedAge" => Ok(Field::SuggestedAge),
844						"suggestedGender" => Ok(Field::SuggestedGender),
845						"suggestedMeasurement" => Ok(Field::SuggestedMeasurement),
846						"supersededBy" => Ok(Field::SupersededBy),
847						"additionalProperty" => Ok(Field::AdditionalProperty),
848						"equal" => Ok(Field::Equal),
849						"greater" => Ok(Field::Greater),
850						"greaterOrEqual" => Ok(Field::GreaterOrEqual),
851						"lesser" => Ok(Field::Lesser),
852						"lesserOrEqual" => Ok(Field::LesserOrEqual),
853						"nonEqual" => Ok(Field::NonEqual),
854						"valueReference" => Ok(Field::ValueReference),
855						"additionalType" => Ok(Field::AdditionalType),
856						"alternateName" => Ok(Field::AlternateName),
857						"description" => Ok(Field::Description),
858						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
859						"identifier" => Ok(Field::Identifier),
860						"image" => Ok(Field::Image),
861						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
862						"name" => Ok(Field::Name),
863						"potentialAction" => Ok(Field::PotentialAction),
864						"sameAs" => Ok(Field::SameAs),
865						"subjectOf" => Ok(Field::SubjectOf),
866						"url" => Ok(Field::Url),
867						"id" | "type" => Ok(Field::Ignore),
868						_ => Err(de::Error::unknown_field(value, FIELDS)),
869					}
870				}
871				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
872				where
873					E: de::Error,
874				{
875					match value {
876						b"hasMeasurement" => Ok(Field::HasMeasurement),
877						b"sizeGroup" => Ok(Field::SizeGroup),
878						b"sizeSystem" => Ok(Field::SizeSystem),
879						b"suggestedAge" => Ok(Field::SuggestedAge),
880						b"suggestedGender" => Ok(Field::SuggestedGender),
881						b"suggestedMeasurement" => Ok(Field::SuggestedMeasurement),
882						b"supersededBy" => Ok(Field::SupersededBy),
883						b"additionalProperty" => Ok(Field::AdditionalProperty),
884						b"equal" => Ok(Field::Equal),
885						b"greater" => Ok(Field::Greater),
886						b"greaterOrEqual" => Ok(Field::GreaterOrEqual),
887						b"lesser" => Ok(Field::Lesser),
888						b"lesserOrEqual" => Ok(Field::LesserOrEqual),
889						b"nonEqual" => Ok(Field::NonEqual),
890						b"valueReference" => Ok(Field::ValueReference),
891						b"additionalType" => Ok(Field::AdditionalType),
892						b"alternateName" => Ok(Field::AlternateName),
893						b"description" => Ok(Field::Description),
894						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
895						b"identifier" => Ok(Field::Identifier),
896						b"image" => Ok(Field::Image),
897						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
898						b"name" => Ok(Field::Name),
899						b"potentialAction" => Ok(Field::PotentialAction),
900						b"sameAs" => Ok(Field::SameAs),
901						b"subjectOf" => Ok(Field::SubjectOf),
902						b"url" => Ok(Field::Url),
903						b"id" | b"type" => Ok(Field::Ignore),
904						_ => {
905							let value = &String::from_utf8_lossy(value);
906							Err(de::Error::unknown_field(value, FIELDS))
907						}
908					}
909				}
910			}
911			impl<'de> Deserialize<'de> for Field {
912				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
913				where
914					D: Deserializer<'de>,
915				{
916					deserializer.deserialize_identifier(FieldVisitor)
917				}
918			}
919			struct ClassVisitor;
920			impl<'de> Visitor<'de> for ClassVisitor {
921				type Value = SizeSpecification;
922				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
923					formatter.write_str("schema.org schema SizeSpecification")
924				}
925				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
926				where
927					A: de::MapAccess<'de>,
928				{
929					let mut r#has_measurement_property = None;
930					let mut r#size_group_property = None;
931					let mut r#size_system_property = None;
932					let mut r#suggested_age_property = None;
933					let mut r#suggested_gender_property = None;
934					let mut r#suggested_measurement_property = None;
935					let mut r#superseded_by_property = None;
936					let mut r#additional_property_property = None;
937					let mut r#equal_property = None;
938					let mut r#greater_property = None;
939					let mut r#greater_or_equal_property = None;
940					let mut r#lesser_property = None;
941					let mut r#lesser_or_equal_property = None;
942					let mut r#non_equal_property = None;
943					let mut r#value_reference_property = None;
944					let mut r#additional_type_property = None;
945					let mut r#alternate_name_property = None;
946					let mut r#description_property = None;
947					let mut r#disambiguating_description_property = None;
948					let mut r#identifier_property = None;
949					let mut r#image_property = None;
950					let mut r#main_entity_of_page_property = None;
951					let mut r#name_property = None;
952					let mut r#potential_action_property = None;
953					let mut r#same_as_property = None;
954					let mut r#subject_of_property = None;
955					let mut r#url_property = None;
956					while let Some(key) = map.next_key::<Field>()? {
957						match key {
958							Field::HasMeasurement => {
959								if r#has_measurement_property.is_some() {
960									return Err(<A::Error as de::Error>::duplicate_field(
961										"hasMeasurement",
962									));
963								}
964								r#has_measurement_property = Some({
965									struct DeserializeWith(Vec<HasMeasurementProperty>);
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::SizeGroup => {
985								if r#size_group_property.is_some() {
986									return Err(<A::Error as de::Error>::duplicate_field(
987										"sizeGroup",
988									));
989								}
990								r#size_group_property = Some({
991									struct DeserializeWith(Vec<SizeGroupProperty>);
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::SizeSystem => {
1011								if r#size_system_property.is_some() {
1012									return Err(<A::Error as de::Error>::duplicate_field(
1013										"sizeSystem",
1014									));
1015								}
1016								r#size_system_property = Some({
1017									struct DeserializeWith(Vec<SizeSystemProperty>);
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::SuggestedAge => {
1037								if r#suggested_age_property.is_some() {
1038									return Err(<A::Error as de::Error>::duplicate_field(
1039										"suggestedAge",
1040									));
1041								}
1042								r#suggested_age_property = Some({
1043									struct DeserializeWith(Vec<SuggestedAgeProperty>);
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::SuggestedGender => {
1063								if r#suggested_gender_property.is_some() {
1064									return Err(<A::Error as de::Error>::duplicate_field(
1065										"suggestedGender",
1066									));
1067								}
1068								r#suggested_gender_property = Some({
1069									struct DeserializeWith(Vec<SuggestedGenderProperty>);
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::SuggestedMeasurement => {
1089								if r#suggested_measurement_property.is_some() {
1090									return Err(<A::Error as de::Error>::duplicate_field(
1091										"suggestedMeasurement",
1092									));
1093								}
1094								r#suggested_measurement_property = Some({
1095									struct DeserializeWith(Vec<SuggestedMeasurementProperty>);
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::SupersededBy => {
1115								if r#superseded_by_property.is_some() {
1116									return Err(<A::Error as de::Error>::duplicate_field(
1117										"supersededBy",
1118									));
1119								}
1120								r#superseded_by_property = Some({
1121									struct DeserializeWith(Vec<SupersededByProperty>);
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::AdditionalProperty => {
1141								if r#additional_property_property.is_some() {
1142									return Err(<A::Error as de::Error>::duplicate_field(
1143										"additionalProperty",
1144									));
1145								}
1146								r#additional_property_property = Some({
1147									struct DeserializeWith(Vec<AdditionalPropertyProperty>);
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::Equal => {
1167								if r#equal_property.is_some() {
1168									return Err(<A::Error as de::Error>::duplicate_field("equal"));
1169								}
1170								r#equal_property = Some({
1171									struct DeserializeWith(Vec<EqualProperty>);
1172									impl<'de> Deserialize<'de> for DeserializeWith {
1173										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1174										where
1175											D: Deserializer<'de>,
1176										{
1177											Ok(DeserializeWith(serde_with::As::<
1178												serde_with::OneOrMany<serde_with::Same>,
1179											>::deserialize(deserializer)?))
1180										}
1181									}
1182									match map.next_value::<DeserializeWith>() {
1183										Ok(deserialize_with) => deserialize_with.0,
1184										Err(err) => {
1185											return Err(err);
1186										}
1187									}
1188								});
1189							}
1190							Field::Greater => {
1191								if r#greater_property.is_some() {
1192									return Err(<A::Error as de::Error>::duplicate_field(
1193										"greater",
1194									));
1195								}
1196								r#greater_property = Some({
1197									struct DeserializeWith(Vec<GreaterProperty>);
1198									impl<'de> Deserialize<'de> for DeserializeWith {
1199										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1200										where
1201											D: Deserializer<'de>,
1202										{
1203											Ok(DeserializeWith(serde_with::As::<
1204												serde_with::OneOrMany<serde_with::Same>,
1205											>::deserialize(deserializer)?))
1206										}
1207									}
1208									match map.next_value::<DeserializeWith>() {
1209										Ok(deserialize_with) => deserialize_with.0,
1210										Err(err) => {
1211											return Err(err);
1212										}
1213									}
1214								});
1215							}
1216							Field::GreaterOrEqual => {
1217								if r#greater_or_equal_property.is_some() {
1218									return Err(<A::Error as de::Error>::duplicate_field(
1219										"greaterOrEqual",
1220									));
1221								}
1222								r#greater_or_equal_property = Some({
1223									struct DeserializeWith(Vec<GreaterOrEqualProperty>);
1224									impl<'de> Deserialize<'de> for DeserializeWith {
1225										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1226										where
1227											D: Deserializer<'de>,
1228										{
1229											Ok(DeserializeWith(serde_with::As::<
1230												serde_with::OneOrMany<serde_with::Same>,
1231											>::deserialize(deserializer)?))
1232										}
1233									}
1234									match map.next_value::<DeserializeWith>() {
1235										Ok(deserialize_with) => deserialize_with.0,
1236										Err(err) => {
1237											return Err(err);
1238										}
1239									}
1240								});
1241							}
1242							Field::Lesser => {
1243								if r#lesser_property.is_some() {
1244									return Err(<A::Error as de::Error>::duplicate_field("lesser"));
1245								}
1246								r#lesser_property = Some({
1247									struct DeserializeWith(Vec<LesserProperty>);
1248									impl<'de> Deserialize<'de> for DeserializeWith {
1249										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1250										where
1251											D: Deserializer<'de>,
1252										{
1253											Ok(DeserializeWith(serde_with::As::<
1254												serde_with::OneOrMany<serde_with::Same>,
1255											>::deserialize(deserializer)?))
1256										}
1257									}
1258									match map.next_value::<DeserializeWith>() {
1259										Ok(deserialize_with) => deserialize_with.0,
1260										Err(err) => {
1261											return Err(err);
1262										}
1263									}
1264								});
1265							}
1266							Field::LesserOrEqual => {
1267								if r#lesser_or_equal_property.is_some() {
1268									return Err(<A::Error as de::Error>::duplicate_field(
1269										"lesserOrEqual",
1270									));
1271								}
1272								r#lesser_or_equal_property = Some({
1273									struct DeserializeWith(Vec<LesserOrEqualProperty>);
1274									impl<'de> Deserialize<'de> for DeserializeWith {
1275										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1276										where
1277											D: Deserializer<'de>,
1278										{
1279											Ok(DeserializeWith(serde_with::As::<
1280												serde_with::OneOrMany<serde_with::Same>,
1281											>::deserialize(deserializer)?))
1282										}
1283									}
1284									match map.next_value::<DeserializeWith>() {
1285										Ok(deserialize_with) => deserialize_with.0,
1286										Err(err) => {
1287											return Err(err);
1288										}
1289									}
1290								});
1291							}
1292							Field::NonEqual => {
1293								if r#non_equal_property.is_some() {
1294									return Err(<A::Error as de::Error>::duplicate_field(
1295										"nonEqual",
1296									));
1297								}
1298								r#non_equal_property = Some({
1299									struct DeserializeWith(Vec<NonEqualProperty>);
1300									impl<'de> Deserialize<'de> for DeserializeWith {
1301										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1302										where
1303											D: Deserializer<'de>,
1304										{
1305											Ok(DeserializeWith(serde_with::As::<
1306												serde_with::OneOrMany<serde_with::Same>,
1307											>::deserialize(deserializer)?))
1308										}
1309									}
1310									match map.next_value::<DeserializeWith>() {
1311										Ok(deserialize_with) => deserialize_with.0,
1312										Err(err) => {
1313											return Err(err);
1314										}
1315									}
1316								});
1317							}
1318							Field::ValueReference => {
1319								if r#value_reference_property.is_some() {
1320									return Err(<A::Error as de::Error>::duplicate_field(
1321										"valueReference",
1322									));
1323								}
1324								r#value_reference_property = Some({
1325									struct DeserializeWith(Vec<ValueReferenceProperty>);
1326									impl<'de> Deserialize<'de> for DeserializeWith {
1327										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1328										where
1329											D: Deserializer<'de>,
1330										{
1331											Ok(DeserializeWith(serde_with::As::<
1332												serde_with::OneOrMany<serde_with::Same>,
1333											>::deserialize(deserializer)?))
1334										}
1335									}
1336									match map.next_value::<DeserializeWith>() {
1337										Ok(deserialize_with) => deserialize_with.0,
1338										Err(err) => {
1339											return Err(err);
1340										}
1341									}
1342								});
1343							}
1344							Field::AdditionalType => {
1345								if r#additional_type_property.is_some() {
1346									return Err(<A::Error as de::Error>::duplicate_field(
1347										"additionalType",
1348									));
1349								}
1350								r#additional_type_property = Some({
1351									struct DeserializeWith(Vec<AdditionalTypeProperty>);
1352									impl<'de> Deserialize<'de> for DeserializeWith {
1353										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1354										where
1355											D: Deserializer<'de>,
1356										{
1357											Ok(DeserializeWith(serde_with::As::<
1358												serde_with::OneOrMany<serde_with::Same>,
1359											>::deserialize(deserializer)?))
1360										}
1361									}
1362									match map.next_value::<DeserializeWith>() {
1363										Ok(deserialize_with) => deserialize_with.0,
1364										Err(err) => {
1365											return Err(err);
1366										}
1367									}
1368								});
1369							}
1370							Field::AlternateName => {
1371								if r#alternate_name_property.is_some() {
1372									return Err(<A::Error as de::Error>::duplicate_field(
1373										"alternateName",
1374									));
1375								}
1376								r#alternate_name_property = Some({
1377									struct DeserializeWith(Vec<AlternateNameProperty>);
1378									impl<'de> Deserialize<'de> for DeserializeWith {
1379										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1380										where
1381											D: Deserializer<'de>,
1382										{
1383											Ok(DeserializeWith(serde_with::As::<
1384												serde_with::OneOrMany<serde_with::Same>,
1385											>::deserialize(deserializer)?))
1386										}
1387									}
1388									match map.next_value::<DeserializeWith>() {
1389										Ok(deserialize_with) => deserialize_with.0,
1390										Err(err) => {
1391											return Err(err);
1392										}
1393									}
1394								});
1395							}
1396							Field::Description => {
1397								if r#description_property.is_some() {
1398									return Err(<A::Error as de::Error>::duplicate_field(
1399										"description",
1400									));
1401								}
1402								r#description_property = Some({
1403									struct DeserializeWith(Vec<DescriptionProperty>);
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::DisambiguatingDescription => {
1423								if r#disambiguating_description_property.is_some() {
1424									return Err(<A::Error as de::Error>::duplicate_field(
1425										"disambiguatingDescription",
1426									));
1427								}
1428								r#disambiguating_description_property = Some({
1429									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
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::Identifier => {
1449								if r#identifier_property.is_some() {
1450									return Err(<A::Error as de::Error>::duplicate_field(
1451										"identifier",
1452									));
1453								}
1454								r#identifier_property = Some({
1455									struct DeserializeWith(Vec<IdentifierProperty>);
1456									impl<'de> Deserialize<'de> for DeserializeWith {
1457										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1458										where
1459											D: Deserializer<'de>,
1460										{
1461											Ok(DeserializeWith(serde_with::As::<
1462												serde_with::OneOrMany<serde_with::Same>,
1463											>::deserialize(deserializer)?))
1464										}
1465									}
1466									match map.next_value::<DeserializeWith>() {
1467										Ok(deserialize_with) => deserialize_with.0,
1468										Err(err) => {
1469											return Err(err);
1470										}
1471									}
1472								});
1473							}
1474							Field::Image => {
1475								if r#image_property.is_some() {
1476									return Err(<A::Error as de::Error>::duplicate_field("image"));
1477								}
1478								r#image_property = Some({
1479									struct DeserializeWith(Vec<ImageProperty>);
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::MainEntityOfPage => {
1499								if r#main_entity_of_page_property.is_some() {
1500									return Err(<A::Error as de::Error>::duplicate_field(
1501										"mainEntityOfPage",
1502									));
1503								}
1504								r#main_entity_of_page_property = Some({
1505									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1506									impl<'de> Deserialize<'de> for DeserializeWith {
1507										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1508										where
1509											D: Deserializer<'de>,
1510										{
1511											Ok(DeserializeWith(serde_with::As::<
1512												serde_with::OneOrMany<serde_with::Same>,
1513											>::deserialize(deserializer)?))
1514										}
1515									}
1516									match map.next_value::<DeserializeWith>() {
1517										Ok(deserialize_with) => deserialize_with.0,
1518										Err(err) => {
1519											return Err(err);
1520										}
1521									}
1522								});
1523							}
1524							Field::Name => {
1525								if r#name_property.is_some() {
1526									return Err(<A::Error as de::Error>::duplicate_field("name"));
1527								}
1528								r#name_property = Some({
1529									struct DeserializeWith(Vec<NameProperty>);
1530									impl<'de> Deserialize<'de> for DeserializeWith {
1531										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1532										where
1533											D: Deserializer<'de>,
1534										{
1535											Ok(DeserializeWith(serde_with::As::<
1536												serde_with::OneOrMany<serde_with::Same>,
1537											>::deserialize(deserializer)?))
1538										}
1539									}
1540									match map.next_value::<DeserializeWith>() {
1541										Ok(deserialize_with) => deserialize_with.0,
1542										Err(err) => {
1543											return Err(err);
1544										}
1545									}
1546								});
1547							}
1548							Field::PotentialAction => {
1549								if r#potential_action_property.is_some() {
1550									return Err(<A::Error as de::Error>::duplicate_field(
1551										"potentialAction",
1552									));
1553								}
1554								r#potential_action_property = Some({
1555									struct DeserializeWith(Vec<PotentialActionProperty>);
1556									impl<'de> Deserialize<'de> for DeserializeWith {
1557										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1558										where
1559											D: Deserializer<'de>,
1560										{
1561											Ok(DeserializeWith(serde_with::As::<
1562												serde_with::OneOrMany<serde_with::Same>,
1563											>::deserialize(deserializer)?))
1564										}
1565									}
1566									match map.next_value::<DeserializeWith>() {
1567										Ok(deserialize_with) => deserialize_with.0,
1568										Err(err) => {
1569											return Err(err);
1570										}
1571									}
1572								});
1573							}
1574							Field::SameAs => {
1575								if r#same_as_property.is_some() {
1576									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1577								}
1578								r#same_as_property = Some({
1579									struct DeserializeWith(Vec<SameAsProperty>);
1580									impl<'de> Deserialize<'de> for DeserializeWith {
1581										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1582										where
1583											D: Deserializer<'de>,
1584										{
1585											Ok(DeserializeWith(serde_with::As::<
1586												serde_with::OneOrMany<serde_with::Same>,
1587											>::deserialize(deserializer)?))
1588										}
1589									}
1590									match map.next_value::<DeserializeWith>() {
1591										Ok(deserialize_with) => deserialize_with.0,
1592										Err(err) => {
1593											return Err(err);
1594										}
1595									}
1596								});
1597							}
1598							Field::SubjectOf => {
1599								if r#subject_of_property.is_some() {
1600									return Err(<A::Error as de::Error>::duplicate_field(
1601										"subjectOf",
1602									));
1603								}
1604								r#subject_of_property = Some({
1605									struct DeserializeWith(Vec<SubjectOfProperty>);
1606									impl<'de> Deserialize<'de> for DeserializeWith {
1607										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1608										where
1609											D: Deserializer<'de>,
1610										{
1611											Ok(DeserializeWith(serde_with::As::<
1612												serde_with::OneOrMany<serde_with::Same>,
1613											>::deserialize(deserializer)?))
1614										}
1615									}
1616									match map.next_value::<DeserializeWith>() {
1617										Ok(deserialize_with) => deserialize_with.0,
1618										Err(err) => {
1619											return Err(err);
1620										}
1621									}
1622								});
1623							}
1624							Field::Url => {
1625								if r#url_property.is_some() {
1626									return Err(<A::Error as de::Error>::duplicate_field("url"));
1627								}
1628								r#url_property = Some({
1629									struct DeserializeWith(Vec<UrlProperty>);
1630									impl<'de> Deserialize<'de> for DeserializeWith {
1631										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1632										where
1633											D: Deserializer<'de>,
1634										{
1635											Ok(DeserializeWith(serde_with::As::<
1636												serde_with::OneOrMany<serde_with::Same>,
1637											>::deserialize(deserializer)?))
1638										}
1639									}
1640									match map.next_value::<DeserializeWith>() {
1641										Ok(deserialize_with) => deserialize_with.0,
1642										Err(err) => {
1643											return Err(err);
1644										}
1645									}
1646								});
1647							}
1648							Field::Ignore => {
1649								let _ = map.next_value::<de::IgnoredAny>()?;
1650							}
1651						}
1652					}
1653					Ok(SizeSpecification {
1654						r#has_measurement: r#has_measurement_property.unwrap_or_default(),
1655						r#size_group: r#size_group_property.unwrap_or_default(),
1656						r#size_system: r#size_system_property.unwrap_or_default(),
1657						r#suggested_age: r#suggested_age_property.unwrap_or_default(),
1658						r#suggested_gender: r#suggested_gender_property.unwrap_or_default(),
1659						r#suggested_measurement: r#suggested_measurement_property
1660							.unwrap_or_default(),
1661						r#superseded_by: r#superseded_by_property.unwrap_or_default(),
1662						r#additional_property: r#additional_property_property.unwrap_or_default(),
1663						r#equal: r#equal_property.unwrap_or_default(),
1664						r#greater: r#greater_property.unwrap_or_default(),
1665						r#greater_or_equal: r#greater_or_equal_property.unwrap_or_default(),
1666						r#lesser: r#lesser_property.unwrap_or_default(),
1667						r#lesser_or_equal: r#lesser_or_equal_property.unwrap_or_default(),
1668						r#non_equal: r#non_equal_property.unwrap_or_default(),
1669						r#value_reference: r#value_reference_property.unwrap_or_default(),
1670						r#additional_type: r#additional_type_property.unwrap_or_default(),
1671						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1672						r#description: r#description_property.unwrap_or_default(),
1673						r#disambiguating_description: r#disambiguating_description_property
1674							.unwrap_or_default(),
1675						r#identifier: r#identifier_property.unwrap_or_default(),
1676						r#image: r#image_property.unwrap_or_default(),
1677						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1678						r#name: r#name_property.unwrap_or_default(),
1679						r#potential_action: r#potential_action_property.unwrap_or_default(),
1680						r#same_as: r#same_as_property.unwrap_or_default(),
1681						r#subject_of: r#subject_of_property.unwrap_or_default(),
1682						r#url: r#url_property.unwrap_or_default(),
1683					})
1684				}
1685			}
1686			const FIELDS: &[&str] = &[
1687				"hasMeasurement",
1688				"sizeGroup",
1689				"sizeSystem",
1690				"suggestedAge",
1691				"suggestedGender",
1692				"suggestedMeasurement",
1693				"supersededBy",
1694				"additionalProperty",
1695				"equal",
1696				"greater",
1697				"greaterOrEqual",
1698				"lesser",
1699				"lesserOrEqual",
1700				"nonEqual",
1701				"valueReference",
1702				"additionalType",
1703				"alternateName",
1704				"description",
1705				"disambiguatingDescription",
1706				"identifier",
1707				"image",
1708				"mainEntityOfPage",
1709				"name",
1710				"potentialAction",
1711				"sameAs",
1712				"subjectOf",
1713				"url",
1714			];
1715			deserializer.deserialize_struct("SizeSpecification", FIELDS, ClassVisitor)
1716		}
1717	}
1718}
schema_org_types/schemas/classes/size_specification.rs

schema_org_types/schemas/classes/
size_specification.rs
