schema_org_types/schemas/classes/
enumeration.rs

1use super::*;
2/// <https://schema.org/Enumeration>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Enumeration {
6	/// <https://schema.org/supersededBy>
7	pub r#superseded_by: Vec<SupersededByProperty>,
8	/// <https://schema.org/additionalType>
9	pub r#additional_type: Vec<AdditionalTypeProperty>,
10	/// <https://schema.org/alternateName>
11	pub r#alternate_name: Vec<AlternateNameProperty>,
12	/// <https://schema.org/description>
13	pub r#description: Vec<DescriptionProperty>,
14	/// <https://schema.org/disambiguatingDescription>
15	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
16	/// <https://schema.org/identifier>
17	pub r#identifier: Vec<IdentifierProperty>,
18	/// <https://schema.org/image>
19	pub r#image: Vec<ImageProperty>,
20	/// <https://schema.org/mainEntityOfPage>
21	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
22	/// <https://schema.org/name>
23	pub r#name: Vec<NameProperty>,
24	/// <https://schema.org/potentialAction>
25	pub r#potential_action: Vec<PotentialActionProperty>,
26	/// <https://schema.org/sameAs>
27	pub r#same_as: Vec<SameAsProperty>,
28	/// <https://schema.org/subjectOf>
29	pub r#subject_of: Vec<SubjectOfProperty>,
30	/// <https://schema.org/url>
31	pub r#url: Vec<UrlProperty>,
32}
33/// This trait is for properties from <https://schema.org/Enumeration>.
34pub trait EnumerationTrait {
35	/// Get <https://schema.org/supersededBy> from [`Self`] as borrowed slice.
36	fn get_superseded_by(&self) -> &[SupersededByProperty];
37	/// Take <https://schema.org/supersededBy> from [`Self`] as owned vector.
38	fn take_superseded_by(&mut self) -> Vec<SupersededByProperty>;
39}
40impl EnumerationTrait for Enumeration {
41	fn get_superseded_by(&self) -> &[SupersededByProperty] {
42		self.r#superseded_by.as_slice()
43	}
44	fn take_superseded_by(&mut self) -> Vec<SupersededByProperty> {
45		std::mem::take(&mut self.r#superseded_by)
46	}
47}
48impl ThingTrait for Enumeration {
49	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
50		self.r#additional_type.as_slice()
51	}
52	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
53		std::mem::take(&mut self.r#additional_type)
54	}
55	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
56		self.r#alternate_name.as_slice()
57	}
58	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
59		std::mem::take(&mut self.r#alternate_name)
60	}
61	fn get_description(&self) -> &[DescriptionProperty] {
62		self.r#description.as_slice()
63	}
64	fn take_description(&mut self) -> Vec<DescriptionProperty> {
65		std::mem::take(&mut self.r#description)
66	}
67	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
68		self.r#disambiguating_description.as_slice()
69	}
70	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
71		std::mem::take(&mut self.r#disambiguating_description)
72	}
73	fn get_identifier(&self) -> &[IdentifierProperty] {
74		self.r#identifier.as_slice()
75	}
76	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
77		std::mem::take(&mut self.r#identifier)
78	}
79	fn get_image(&self) -> &[ImageProperty] {
80		self.r#image.as_slice()
81	}
82	fn take_image(&mut self) -> Vec<ImageProperty> {
83		std::mem::take(&mut self.r#image)
84	}
85	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
86		self.r#main_entity_of_page.as_slice()
87	}
88	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
89		std::mem::take(&mut self.r#main_entity_of_page)
90	}
91	fn get_name(&self) -> &[NameProperty] {
92		self.r#name.as_slice()
93	}
94	fn take_name(&mut self) -> Vec<NameProperty> {
95		std::mem::take(&mut self.r#name)
96	}
97	fn get_potential_action(&self) -> &[PotentialActionProperty] {
98		self.r#potential_action.as_slice()
99	}
100	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
101		std::mem::take(&mut self.r#potential_action)
102	}
103	fn get_same_as(&self) -> &[SameAsProperty] {
104		self.r#same_as.as_slice()
105	}
106	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
107		std::mem::take(&mut self.r#same_as)
108	}
109	fn get_subject_of(&self) -> &[SubjectOfProperty] {
110		self.r#subject_of.as_slice()
111	}
112	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
113		std::mem::take(&mut self.r#subject_of)
114	}
115	fn get_url(&self) -> &[UrlProperty] {
116		self.r#url.as_slice()
117	}
118	fn take_url(&mut self) -> Vec<UrlProperty> {
119		std::mem::take(&mut self.r#url)
120	}
121}
122#[cfg(feature = "serde")]
123mod serde {
124	use std::{fmt, fmt::Formatter};
125
126	use ::serde::{
127		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
128	};
129
130	use super::*;
131	impl Serialize for Enumeration {
132		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
133		where
134			S: Serializer,
135		{
136			let len: usize = [
137				!Vec::is_empty(&self.r#superseded_by) as usize,
138				!Vec::is_empty(&self.r#additional_type) as usize,
139				!Vec::is_empty(&self.r#alternate_name) as usize,
140				!Vec::is_empty(&self.r#description) as usize,
141				!Vec::is_empty(&self.r#disambiguating_description) as usize,
142				!Vec::is_empty(&self.r#identifier) as usize,
143				!Vec::is_empty(&self.r#image) as usize,
144				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
145				!Vec::is_empty(&self.r#name) as usize,
146				!Vec::is_empty(&self.r#potential_action) as usize,
147				!Vec::is_empty(&self.r#same_as) as usize,
148				!Vec::is_empty(&self.r#subject_of) as usize,
149				!Vec::is_empty(&self.r#url) as usize,
150			]
151			.iter()
152			.sum();
153			let mut serialize_struct =
154				Serializer::serialize_struct(serializer, "Enumeration", len)?;
155			if !Vec::is_empty(&self.r#superseded_by) {
156				serialize_struct.serialize_field("supersededBy", {
157					struct SerializeWith<'a>(&'a Vec<SupersededByProperty>);
158					impl<'a> Serialize for SerializeWith<'a> {
159						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
160						where
161							S: Serializer,
162						{
163							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
164								self.0, serializer,
165							)
166						}
167					}
168					&SerializeWith(&self.r#superseded_by)
169				})?;
170			} else {
171				serialize_struct.skip_field("supersededBy")?;
172			}
173			if !Vec::is_empty(&self.r#additional_type) {
174				serialize_struct.serialize_field("additionalType", {
175					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
176					impl<'a> Serialize for SerializeWith<'a> {
177						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
178						where
179							S: Serializer,
180						{
181							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
182								self.0, serializer,
183							)
184						}
185					}
186					&SerializeWith(&self.r#additional_type)
187				})?;
188			} else {
189				serialize_struct.skip_field("additionalType")?;
190			}
191			if !Vec::is_empty(&self.r#alternate_name) {
192				serialize_struct.serialize_field("alternateName", {
193					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
194					impl<'a> Serialize for SerializeWith<'a> {
195						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
196						where
197							S: Serializer,
198						{
199							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
200								self.0, serializer,
201							)
202						}
203					}
204					&SerializeWith(&self.r#alternate_name)
205				})?;
206			} else {
207				serialize_struct.skip_field("alternateName")?;
208			}
209			if !Vec::is_empty(&self.r#description) {
210				serialize_struct.serialize_field("description", {
211					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
212					impl<'a> Serialize for SerializeWith<'a> {
213						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
214						where
215							S: Serializer,
216						{
217							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
218								self.0, serializer,
219							)
220						}
221					}
222					&SerializeWith(&self.r#description)
223				})?;
224			} else {
225				serialize_struct.skip_field("description")?;
226			}
227			if !Vec::is_empty(&self.r#disambiguating_description) {
228				serialize_struct.serialize_field("disambiguatingDescription", {
229					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
230					impl<'a> Serialize for SerializeWith<'a> {
231						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
232						where
233							S: Serializer,
234						{
235							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
236								self.0, serializer,
237							)
238						}
239					}
240					&SerializeWith(&self.r#disambiguating_description)
241				})?;
242			} else {
243				serialize_struct.skip_field("disambiguatingDescription")?;
244			}
245			if !Vec::is_empty(&self.r#identifier) {
246				serialize_struct.serialize_field("identifier", {
247					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
248					impl<'a> Serialize for SerializeWith<'a> {
249						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
250						where
251							S: Serializer,
252						{
253							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
254								self.0, serializer,
255							)
256						}
257					}
258					&SerializeWith(&self.r#identifier)
259				})?;
260			} else {
261				serialize_struct.skip_field("identifier")?;
262			}
263			if !Vec::is_empty(&self.r#image) {
264				serialize_struct.serialize_field("image", {
265					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
266					impl<'a> Serialize for SerializeWith<'a> {
267						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
268						where
269							S: Serializer,
270						{
271							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
272								self.0, serializer,
273							)
274						}
275					}
276					&SerializeWith(&self.r#image)
277				})?;
278			} else {
279				serialize_struct.skip_field("image")?;
280			}
281			if !Vec::is_empty(&self.r#main_entity_of_page) {
282				serialize_struct.serialize_field("mainEntityOfPage", {
283					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
284					impl<'a> Serialize for SerializeWith<'a> {
285						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
286						where
287							S: Serializer,
288						{
289							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
290								self.0, serializer,
291							)
292						}
293					}
294					&SerializeWith(&self.r#main_entity_of_page)
295				})?;
296			} else {
297				serialize_struct.skip_field("mainEntityOfPage")?;
298			}
299			if !Vec::is_empty(&self.r#name) {
300				serialize_struct.serialize_field("name", {
301					struct SerializeWith<'a>(&'a Vec<NameProperty>);
302					impl<'a> Serialize for SerializeWith<'a> {
303						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
304						where
305							S: Serializer,
306						{
307							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
308								self.0, serializer,
309							)
310						}
311					}
312					&SerializeWith(&self.r#name)
313				})?;
314			} else {
315				serialize_struct.skip_field("name")?;
316			}
317			if !Vec::is_empty(&self.r#potential_action) {
318				serialize_struct.serialize_field("potentialAction", {
319					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
320					impl<'a> Serialize for SerializeWith<'a> {
321						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
322						where
323							S: Serializer,
324						{
325							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
326								self.0, serializer,
327							)
328						}
329					}
330					&SerializeWith(&self.r#potential_action)
331				})?;
332			} else {
333				serialize_struct.skip_field("potentialAction")?;
334			}
335			if !Vec::is_empty(&self.r#same_as) {
336				serialize_struct.serialize_field("sameAs", {
337					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
338					impl<'a> Serialize for SerializeWith<'a> {
339						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
340						where
341							S: Serializer,
342						{
343							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
344								self.0, serializer,
345							)
346						}
347					}
348					&SerializeWith(&self.r#same_as)
349				})?;
350			} else {
351				serialize_struct.skip_field("sameAs")?;
352			}
353			if !Vec::is_empty(&self.r#subject_of) {
354				serialize_struct.serialize_field("subjectOf", {
355					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
356					impl<'a> Serialize for SerializeWith<'a> {
357						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
358						where
359							S: Serializer,
360						{
361							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
362								self.0, serializer,
363							)
364						}
365					}
366					&SerializeWith(&self.r#subject_of)
367				})?;
368			} else {
369				serialize_struct.skip_field("subjectOf")?;
370			}
371			if !Vec::is_empty(&self.r#url) {
372				serialize_struct.serialize_field("url", {
373					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
374					impl<'a> Serialize for SerializeWith<'a> {
375						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
376						where
377							S: Serializer,
378						{
379							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
380								self.0, serializer,
381							)
382						}
383					}
384					&SerializeWith(&self.r#url)
385				})?;
386			} else {
387				serialize_struct.skip_field("url")?;
388			}
389			serialize_struct.end()
390		}
391	}
392	impl<'de> Deserialize<'de> for Enumeration {
393		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
394		where
395			D: Deserializer<'de>,
396		{
397			enum Field {
398				SupersededBy,
399				AdditionalType,
400				AlternateName,
401				Description,
402				DisambiguatingDescription,
403				Identifier,
404				Image,
405				MainEntityOfPage,
406				Name,
407				PotentialAction,
408				SameAs,
409				SubjectOf,
410				Url,
411				Ignore,
412			}
413			struct FieldVisitor;
414			impl<'de> Visitor<'de> for FieldVisitor {
415				type Value = Field;
416				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
417					formatter.write_str("field identifier")
418				}
419				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
420				where
421					E: de::Error,
422				{
423					match value {
424						"supersededBy" => Ok(Field::SupersededBy),
425						"additionalType" => Ok(Field::AdditionalType),
426						"alternateName" => Ok(Field::AlternateName),
427						"description" => Ok(Field::Description),
428						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
429						"identifier" => Ok(Field::Identifier),
430						"image" => Ok(Field::Image),
431						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
432						"name" => Ok(Field::Name),
433						"potentialAction" => Ok(Field::PotentialAction),
434						"sameAs" => Ok(Field::SameAs),
435						"subjectOf" => Ok(Field::SubjectOf),
436						"url" => Ok(Field::Url),
437						"id" | "type" => Ok(Field::Ignore),
438						_ => Err(de::Error::unknown_field(value, FIELDS)),
439					}
440				}
441				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
442				where
443					E: de::Error,
444				{
445					match value {
446						b"supersededBy" => Ok(Field::SupersededBy),
447						b"additionalType" => Ok(Field::AdditionalType),
448						b"alternateName" => Ok(Field::AlternateName),
449						b"description" => Ok(Field::Description),
450						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
451						b"identifier" => Ok(Field::Identifier),
452						b"image" => Ok(Field::Image),
453						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
454						b"name" => Ok(Field::Name),
455						b"potentialAction" => Ok(Field::PotentialAction),
456						b"sameAs" => Ok(Field::SameAs),
457						b"subjectOf" => Ok(Field::SubjectOf),
458						b"url" => Ok(Field::Url),
459						b"id" | b"type" => Ok(Field::Ignore),
460						_ => {
461							let value = &String::from_utf8_lossy(value);
462							Err(de::Error::unknown_field(value, FIELDS))
463						}
464					}
465				}
466			}
467			impl<'de> Deserialize<'de> for Field {
468				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
469				where
470					D: Deserializer<'de>,
471				{
472					deserializer.deserialize_identifier(FieldVisitor)
473				}
474			}
475			struct ClassVisitor;
476			impl<'de> Visitor<'de> for ClassVisitor {
477				type Value = Enumeration;
478				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
479					formatter.write_str("schema.org schema Enumeration")
480				}
481				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
482				where
483					A: de::MapAccess<'de>,
484				{
485					let mut r#superseded_by_property = None;
486					let mut r#additional_type_property = None;
487					let mut r#alternate_name_property = None;
488					let mut r#description_property = None;
489					let mut r#disambiguating_description_property = None;
490					let mut r#identifier_property = None;
491					let mut r#image_property = None;
492					let mut r#main_entity_of_page_property = None;
493					let mut r#name_property = None;
494					let mut r#potential_action_property = None;
495					let mut r#same_as_property = None;
496					let mut r#subject_of_property = None;
497					let mut r#url_property = None;
498					while let Some(key) = map.next_key::<Field>()? {
499						match key {
500							Field::SupersededBy => {
501								if r#superseded_by_property.is_some() {
502									return Err(<A::Error as de::Error>::duplicate_field(
503										"supersededBy",
504									));
505								}
506								r#superseded_by_property = Some({
507									struct DeserializeWith(Vec<SupersededByProperty>);
508									impl<'de> Deserialize<'de> for DeserializeWith {
509										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
510										where
511											D: Deserializer<'de>,
512										{
513											Ok(DeserializeWith(serde_with::As::<
514												serde_with::OneOrMany<serde_with::Same>,
515											>::deserialize(deserializer)?))
516										}
517									}
518									match map.next_value::<DeserializeWith>() {
519										Ok(deserialize_with) => deserialize_with.0,
520										Err(err) => {
521											return Err(err);
522										}
523									}
524								});
525							}
526							Field::AdditionalType => {
527								if r#additional_type_property.is_some() {
528									return Err(<A::Error as de::Error>::duplicate_field(
529										"additionalType",
530									));
531								}
532								r#additional_type_property = Some({
533									struct DeserializeWith(Vec<AdditionalTypeProperty>);
534									impl<'de> Deserialize<'de> for DeserializeWith {
535										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
536										where
537											D: Deserializer<'de>,
538										{
539											Ok(DeserializeWith(serde_with::As::<
540												serde_with::OneOrMany<serde_with::Same>,
541											>::deserialize(deserializer)?))
542										}
543									}
544									match map.next_value::<DeserializeWith>() {
545										Ok(deserialize_with) => deserialize_with.0,
546										Err(err) => {
547											return Err(err);
548										}
549									}
550								});
551							}
552							Field::AlternateName => {
553								if r#alternate_name_property.is_some() {
554									return Err(<A::Error as de::Error>::duplicate_field(
555										"alternateName",
556									));
557								}
558								r#alternate_name_property = Some({
559									struct DeserializeWith(Vec<AlternateNameProperty>);
560									impl<'de> Deserialize<'de> for DeserializeWith {
561										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
562										where
563											D: Deserializer<'de>,
564										{
565											Ok(DeserializeWith(serde_with::As::<
566												serde_with::OneOrMany<serde_with::Same>,
567											>::deserialize(deserializer)?))
568										}
569									}
570									match map.next_value::<DeserializeWith>() {
571										Ok(deserialize_with) => deserialize_with.0,
572										Err(err) => {
573											return Err(err);
574										}
575									}
576								});
577							}
578							Field::Description => {
579								if r#description_property.is_some() {
580									return Err(<A::Error as de::Error>::duplicate_field(
581										"description",
582									));
583								}
584								r#description_property = Some({
585									struct DeserializeWith(Vec<DescriptionProperty>);
586									impl<'de> Deserialize<'de> for DeserializeWith {
587										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
588										where
589											D: Deserializer<'de>,
590										{
591											Ok(DeserializeWith(serde_with::As::<
592												serde_with::OneOrMany<serde_with::Same>,
593											>::deserialize(deserializer)?))
594										}
595									}
596									match map.next_value::<DeserializeWith>() {
597										Ok(deserialize_with) => deserialize_with.0,
598										Err(err) => {
599											return Err(err);
600										}
601									}
602								});
603							}
604							Field::DisambiguatingDescription => {
605								if r#disambiguating_description_property.is_some() {
606									return Err(<A::Error as de::Error>::duplicate_field(
607										"disambiguatingDescription",
608									));
609								}
610								r#disambiguating_description_property = Some({
611									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
612									impl<'de> Deserialize<'de> for DeserializeWith {
613										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
614										where
615											D: Deserializer<'de>,
616										{
617											Ok(DeserializeWith(serde_with::As::<
618												serde_with::OneOrMany<serde_with::Same>,
619											>::deserialize(deserializer)?))
620										}
621									}
622									match map.next_value::<DeserializeWith>() {
623										Ok(deserialize_with) => deserialize_with.0,
624										Err(err) => {
625											return Err(err);
626										}
627									}
628								});
629							}
630							Field::Identifier => {
631								if r#identifier_property.is_some() {
632									return Err(<A::Error as de::Error>::duplicate_field(
633										"identifier",
634									));
635								}
636								r#identifier_property = Some({
637									struct DeserializeWith(Vec<IdentifierProperty>);
638									impl<'de> Deserialize<'de> for DeserializeWith {
639										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
640										where
641											D: Deserializer<'de>,
642										{
643											Ok(DeserializeWith(serde_with::As::<
644												serde_with::OneOrMany<serde_with::Same>,
645											>::deserialize(deserializer)?))
646										}
647									}
648									match map.next_value::<DeserializeWith>() {
649										Ok(deserialize_with) => deserialize_with.0,
650										Err(err) => {
651											return Err(err);
652										}
653									}
654								});
655							}
656							Field::Image => {
657								if r#image_property.is_some() {
658									return Err(<A::Error as de::Error>::duplicate_field("image"));
659								}
660								r#image_property = Some({
661									struct DeserializeWith(Vec<ImageProperty>);
662									impl<'de> Deserialize<'de> for DeserializeWith {
663										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
664										where
665											D: Deserializer<'de>,
666										{
667											Ok(DeserializeWith(serde_with::As::<
668												serde_with::OneOrMany<serde_with::Same>,
669											>::deserialize(deserializer)?))
670										}
671									}
672									match map.next_value::<DeserializeWith>() {
673										Ok(deserialize_with) => deserialize_with.0,
674										Err(err) => {
675											return Err(err);
676										}
677									}
678								});
679							}
680							Field::MainEntityOfPage => {
681								if r#main_entity_of_page_property.is_some() {
682									return Err(<A::Error as de::Error>::duplicate_field(
683										"mainEntityOfPage",
684									));
685								}
686								r#main_entity_of_page_property = Some({
687									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
688									impl<'de> Deserialize<'de> for DeserializeWith {
689										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
690										where
691											D: Deserializer<'de>,
692										{
693											Ok(DeserializeWith(serde_with::As::<
694												serde_with::OneOrMany<serde_with::Same>,
695											>::deserialize(deserializer)?))
696										}
697									}
698									match map.next_value::<DeserializeWith>() {
699										Ok(deserialize_with) => deserialize_with.0,
700										Err(err) => {
701											return Err(err);
702										}
703									}
704								});
705							}
706							Field::Name => {
707								if r#name_property.is_some() {
708									return Err(<A::Error as de::Error>::duplicate_field("name"));
709								}
710								r#name_property = Some({
711									struct DeserializeWith(Vec<NameProperty>);
712									impl<'de> Deserialize<'de> for DeserializeWith {
713										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
714										where
715											D: Deserializer<'de>,
716										{
717											Ok(DeserializeWith(serde_with::As::<
718												serde_with::OneOrMany<serde_with::Same>,
719											>::deserialize(deserializer)?))
720										}
721									}
722									match map.next_value::<DeserializeWith>() {
723										Ok(deserialize_with) => deserialize_with.0,
724										Err(err) => {
725											return Err(err);
726										}
727									}
728								});
729							}
730							Field::PotentialAction => {
731								if r#potential_action_property.is_some() {
732									return Err(<A::Error as de::Error>::duplicate_field(
733										"potentialAction",
734									));
735								}
736								r#potential_action_property = Some({
737									struct DeserializeWith(Vec<PotentialActionProperty>);
738									impl<'de> Deserialize<'de> for DeserializeWith {
739										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
740										where
741											D: Deserializer<'de>,
742										{
743											Ok(DeserializeWith(serde_with::As::<
744												serde_with::OneOrMany<serde_with::Same>,
745											>::deserialize(deserializer)?))
746										}
747									}
748									match map.next_value::<DeserializeWith>() {
749										Ok(deserialize_with) => deserialize_with.0,
750										Err(err) => {
751											return Err(err);
752										}
753									}
754								});
755							}
756							Field::SameAs => {
757								if r#same_as_property.is_some() {
758									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
759								}
760								r#same_as_property = Some({
761									struct DeserializeWith(Vec<SameAsProperty>);
762									impl<'de> Deserialize<'de> for DeserializeWith {
763										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
764										where
765											D: Deserializer<'de>,
766										{
767											Ok(DeserializeWith(serde_with::As::<
768												serde_with::OneOrMany<serde_with::Same>,
769											>::deserialize(deserializer)?))
770										}
771									}
772									match map.next_value::<DeserializeWith>() {
773										Ok(deserialize_with) => deserialize_with.0,
774										Err(err) => {
775											return Err(err);
776										}
777									}
778								});
779							}
780							Field::SubjectOf => {
781								if r#subject_of_property.is_some() {
782									return Err(<A::Error as de::Error>::duplicate_field(
783										"subjectOf",
784									));
785								}
786								r#subject_of_property = Some({
787									struct DeserializeWith(Vec<SubjectOfProperty>);
788									impl<'de> Deserialize<'de> for DeserializeWith {
789										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
790										where
791											D: Deserializer<'de>,
792										{
793											Ok(DeserializeWith(serde_with::As::<
794												serde_with::OneOrMany<serde_with::Same>,
795											>::deserialize(deserializer)?))
796										}
797									}
798									match map.next_value::<DeserializeWith>() {
799										Ok(deserialize_with) => deserialize_with.0,
800										Err(err) => {
801											return Err(err);
802										}
803									}
804								});
805							}
806							Field::Url => {
807								if r#url_property.is_some() {
808									return Err(<A::Error as de::Error>::duplicate_field("url"));
809								}
810								r#url_property = Some({
811									struct DeserializeWith(Vec<UrlProperty>);
812									impl<'de> Deserialize<'de> for DeserializeWith {
813										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
814										where
815											D: Deserializer<'de>,
816										{
817											Ok(DeserializeWith(serde_with::As::<
818												serde_with::OneOrMany<serde_with::Same>,
819											>::deserialize(deserializer)?))
820										}
821									}
822									match map.next_value::<DeserializeWith>() {
823										Ok(deserialize_with) => deserialize_with.0,
824										Err(err) => {
825											return Err(err);
826										}
827									}
828								});
829							}
830							Field::Ignore => {
831								let _ = map.next_value::<de::IgnoredAny>()?;
832							}
833						}
834					}
835					Ok(Enumeration {
836						r#superseded_by: r#superseded_by_property.unwrap_or_default(),
837						r#additional_type: r#additional_type_property.unwrap_or_default(),
838						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
839						r#description: r#description_property.unwrap_or_default(),
840						r#disambiguating_description: r#disambiguating_description_property
841							.unwrap_or_default(),
842						r#identifier: r#identifier_property.unwrap_or_default(),
843						r#image: r#image_property.unwrap_or_default(),
844						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
845						r#name: r#name_property.unwrap_or_default(),
846						r#potential_action: r#potential_action_property.unwrap_or_default(),
847						r#same_as: r#same_as_property.unwrap_or_default(),
848						r#subject_of: r#subject_of_property.unwrap_or_default(),
849						r#url: r#url_property.unwrap_or_default(),
850					})
851				}
852			}
853			const FIELDS: &[&str] = &[
854				"supersededBy",
855				"additionalType",
856				"alternateName",
857				"description",
858				"disambiguatingDescription",
859				"identifier",
860				"image",
861				"mainEntityOfPage",
862				"name",
863				"potentialAction",
864				"sameAs",
865				"subjectOf",
866				"url",
867			];
868			deserializer.deserialize_struct("Enumeration", FIELDS, ClassVisitor)
869		}
870	}
871}
schema_org_types/schemas/classes/enumeration.rs

schema_org_types/schemas/classes/
enumeration.rs
