schema_org_types/schemas/classes/
endorsement_rating.rs

1use super::*;
2/// <https://schema.org/EndorsementRating>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct EndorsementRating {
6	/// <https://schema.org/author>
7	pub r#author: Vec<AuthorProperty>,
8	/// <https://schema.org/bestRating>
9	pub r#best_rating: Vec<BestRatingProperty>,
10	/// <https://schema.org/ratingExplanation>
11	pub r#rating_explanation: Vec<RatingExplanationProperty>,
12	/// <https://schema.org/ratingValue>
13	pub r#rating_value: Vec<RatingValueProperty>,
14	/// <https://schema.org/reviewAspect>
15	pub r#review_aspect: Vec<ReviewAspectProperty>,
16	/// <https://schema.org/worstRating>
17	pub r#worst_rating: Vec<WorstRatingProperty>,
18	/// <https://schema.org/additionalType>
19	pub r#additional_type: Vec<AdditionalTypeProperty>,
20	/// <https://schema.org/alternateName>
21	pub r#alternate_name: Vec<AlternateNameProperty>,
22	/// <https://schema.org/description>
23	pub r#description: Vec<DescriptionProperty>,
24	/// <https://schema.org/disambiguatingDescription>
25	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
26	/// <https://schema.org/identifier>
27	pub r#identifier: Vec<IdentifierProperty>,
28	/// <https://schema.org/image>
29	pub r#image: Vec<ImageProperty>,
30	/// <https://schema.org/mainEntityOfPage>
31	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
32	/// <https://schema.org/name>
33	pub r#name: Vec<NameProperty>,
34	/// <https://schema.org/potentialAction>
35	pub r#potential_action: Vec<PotentialActionProperty>,
36	/// <https://schema.org/sameAs>
37	pub r#same_as: Vec<SameAsProperty>,
38	/// <https://schema.org/subjectOf>
39	pub r#subject_of: Vec<SubjectOfProperty>,
40	/// <https://schema.org/url>
41	pub r#url: Vec<UrlProperty>,
42}
43/// This trait is for properties from <https://schema.org/EndorsementRating>.
44pub trait EndorsementRatingTrait {}
45impl EndorsementRatingTrait for EndorsementRating {}
46impl RatingTrait for EndorsementRating {
47	fn get_author(&self) -> &[AuthorProperty] {
48		self.r#author.as_slice()
49	}
50	fn take_author(&mut self) -> Vec<AuthorProperty> {
51		std::mem::take(&mut self.r#author)
52	}
53	fn get_best_rating(&self) -> &[BestRatingProperty] {
54		self.r#best_rating.as_slice()
55	}
56	fn take_best_rating(&mut self) -> Vec<BestRatingProperty> {
57		std::mem::take(&mut self.r#best_rating)
58	}
59	fn get_rating_explanation(&self) -> &[RatingExplanationProperty] {
60		self.r#rating_explanation.as_slice()
61	}
62	fn take_rating_explanation(&mut self) -> Vec<RatingExplanationProperty> {
63		std::mem::take(&mut self.r#rating_explanation)
64	}
65	fn get_rating_value(&self) -> &[RatingValueProperty] {
66		self.r#rating_value.as_slice()
67	}
68	fn take_rating_value(&mut self) -> Vec<RatingValueProperty> {
69		std::mem::take(&mut self.r#rating_value)
70	}
71	fn get_review_aspect(&self) -> &[ReviewAspectProperty] {
72		self.r#review_aspect.as_slice()
73	}
74	fn take_review_aspect(&mut self) -> Vec<ReviewAspectProperty> {
75		std::mem::take(&mut self.r#review_aspect)
76	}
77	fn get_worst_rating(&self) -> &[WorstRatingProperty] {
78		self.r#worst_rating.as_slice()
79	}
80	fn take_worst_rating(&mut self) -> Vec<WorstRatingProperty> {
81		std::mem::take(&mut self.r#worst_rating)
82	}
83}
84impl ThingTrait for EndorsementRating {
85	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
86		self.r#additional_type.as_slice()
87	}
88	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
89		std::mem::take(&mut self.r#additional_type)
90	}
91	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
92		self.r#alternate_name.as_slice()
93	}
94	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
95		std::mem::take(&mut self.r#alternate_name)
96	}
97	fn get_description(&self) -> &[DescriptionProperty] {
98		self.r#description.as_slice()
99	}
100	fn take_description(&mut self) -> Vec<DescriptionProperty> {
101		std::mem::take(&mut self.r#description)
102	}
103	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
104		self.r#disambiguating_description.as_slice()
105	}
106	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
107		std::mem::take(&mut self.r#disambiguating_description)
108	}
109	fn get_identifier(&self) -> &[IdentifierProperty] {
110		self.r#identifier.as_slice()
111	}
112	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
113		std::mem::take(&mut self.r#identifier)
114	}
115	fn get_image(&self) -> &[ImageProperty] {
116		self.r#image.as_slice()
117	}
118	fn take_image(&mut self) -> Vec<ImageProperty> {
119		std::mem::take(&mut self.r#image)
120	}
121	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
122		self.r#main_entity_of_page.as_slice()
123	}
124	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
125		std::mem::take(&mut self.r#main_entity_of_page)
126	}
127	fn get_name(&self) -> &[NameProperty] {
128		self.r#name.as_slice()
129	}
130	fn take_name(&mut self) -> Vec<NameProperty> {
131		std::mem::take(&mut self.r#name)
132	}
133	fn get_potential_action(&self) -> &[PotentialActionProperty] {
134		self.r#potential_action.as_slice()
135	}
136	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
137		std::mem::take(&mut self.r#potential_action)
138	}
139	fn get_same_as(&self) -> &[SameAsProperty] {
140		self.r#same_as.as_slice()
141	}
142	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
143		std::mem::take(&mut self.r#same_as)
144	}
145	fn get_subject_of(&self) -> &[SubjectOfProperty] {
146		self.r#subject_of.as_slice()
147	}
148	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
149		std::mem::take(&mut self.r#subject_of)
150	}
151	fn get_url(&self) -> &[UrlProperty] {
152		self.r#url.as_slice()
153	}
154	fn take_url(&mut self) -> Vec<UrlProperty> {
155		std::mem::take(&mut self.r#url)
156	}
157}
158#[cfg(feature = "serde")]
159mod serde {
160	use std::{fmt, fmt::Formatter};
161
162	use ::serde::{
163		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
164	};
165
166	use super::*;
167	impl Serialize for EndorsementRating {
168		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
169		where
170			S: Serializer,
171		{
172			let len: usize = [
173				!Vec::is_empty(&self.r#author) as usize,
174				!Vec::is_empty(&self.r#best_rating) as usize,
175				!Vec::is_empty(&self.r#rating_explanation) as usize,
176				!Vec::is_empty(&self.r#rating_value) as usize,
177				!Vec::is_empty(&self.r#review_aspect) as usize,
178				!Vec::is_empty(&self.r#worst_rating) as usize,
179				!Vec::is_empty(&self.r#additional_type) as usize,
180				!Vec::is_empty(&self.r#alternate_name) as usize,
181				!Vec::is_empty(&self.r#description) as usize,
182				!Vec::is_empty(&self.r#disambiguating_description) as usize,
183				!Vec::is_empty(&self.r#identifier) as usize,
184				!Vec::is_empty(&self.r#image) as usize,
185				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
186				!Vec::is_empty(&self.r#name) as usize,
187				!Vec::is_empty(&self.r#potential_action) as usize,
188				!Vec::is_empty(&self.r#same_as) as usize,
189				!Vec::is_empty(&self.r#subject_of) as usize,
190				!Vec::is_empty(&self.r#url) as usize,
191			]
192			.iter()
193			.sum();
194			let mut serialize_struct =
195				Serializer::serialize_struct(serializer, "EndorsementRating", len)?;
196			if !Vec::is_empty(&self.r#author) {
197				serialize_struct.serialize_field("author", {
198					struct SerializeWith<'a>(&'a Vec<AuthorProperty>);
199					impl<'a> Serialize for SerializeWith<'a> {
200						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
201						where
202							S: Serializer,
203						{
204							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
205								self.0, serializer,
206							)
207						}
208					}
209					&SerializeWith(&self.r#author)
210				})?;
211			} else {
212				serialize_struct.skip_field("author")?;
213			}
214			if !Vec::is_empty(&self.r#best_rating) {
215				serialize_struct.serialize_field("bestRating", {
216					struct SerializeWith<'a>(&'a Vec<BestRatingProperty>);
217					impl<'a> Serialize for SerializeWith<'a> {
218						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
219						where
220							S: Serializer,
221						{
222							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
223								self.0, serializer,
224							)
225						}
226					}
227					&SerializeWith(&self.r#best_rating)
228				})?;
229			} else {
230				serialize_struct.skip_field("bestRating")?;
231			}
232			if !Vec::is_empty(&self.r#rating_explanation) {
233				serialize_struct.serialize_field("ratingExplanation", {
234					struct SerializeWith<'a>(&'a Vec<RatingExplanationProperty>);
235					impl<'a> Serialize for SerializeWith<'a> {
236						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
237						where
238							S: Serializer,
239						{
240							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
241								self.0, serializer,
242							)
243						}
244					}
245					&SerializeWith(&self.r#rating_explanation)
246				})?;
247			} else {
248				serialize_struct.skip_field("ratingExplanation")?;
249			}
250			if !Vec::is_empty(&self.r#rating_value) {
251				serialize_struct.serialize_field("ratingValue", {
252					struct SerializeWith<'a>(&'a Vec<RatingValueProperty>);
253					impl<'a> Serialize for SerializeWith<'a> {
254						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
255						where
256							S: Serializer,
257						{
258							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
259								self.0, serializer,
260							)
261						}
262					}
263					&SerializeWith(&self.r#rating_value)
264				})?;
265			} else {
266				serialize_struct.skip_field("ratingValue")?;
267			}
268			if !Vec::is_empty(&self.r#review_aspect) {
269				serialize_struct.serialize_field("reviewAspect", {
270					struct SerializeWith<'a>(&'a Vec<ReviewAspectProperty>);
271					impl<'a> Serialize for SerializeWith<'a> {
272						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
273						where
274							S: Serializer,
275						{
276							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
277								self.0, serializer,
278							)
279						}
280					}
281					&SerializeWith(&self.r#review_aspect)
282				})?;
283			} else {
284				serialize_struct.skip_field("reviewAspect")?;
285			}
286			if !Vec::is_empty(&self.r#worst_rating) {
287				serialize_struct.serialize_field("worstRating", {
288					struct SerializeWith<'a>(&'a Vec<WorstRatingProperty>);
289					impl<'a> Serialize for SerializeWith<'a> {
290						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
291						where
292							S: Serializer,
293						{
294							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
295								self.0, serializer,
296							)
297						}
298					}
299					&SerializeWith(&self.r#worst_rating)
300				})?;
301			} else {
302				serialize_struct.skip_field("worstRating")?;
303			}
304			if !Vec::is_empty(&self.r#additional_type) {
305				serialize_struct.serialize_field("additionalType", {
306					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
307					impl<'a> Serialize for SerializeWith<'a> {
308						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
309						where
310							S: Serializer,
311						{
312							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
313								self.0, serializer,
314							)
315						}
316					}
317					&SerializeWith(&self.r#additional_type)
318				})?;
319			} else {
320				serialize_struct.skip_field("additionalType")?;
321			}
322			if !Vec::is_empty(&self.r#alternate_name) {
323				serialize_struct.serialize_field("alternateName", {
324					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
325					impl<'a> Serialize for SerializeWith<'a> {
326						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
327						where
328							S: Serializer,
329						{
330							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
331								self.0, serializer,
332							)
333						}
334					}
335					&SerializeWith(&self.r#alternate_name)
336				})?;
337			} else {
338				serialize_struct.skip_field("alternateName")?;
339			}
340			if !Vec::is_empty(&self.r#description) {
341				serialize_struct.serialize_field("description", {
342					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
343					impl<'a> Serialize for SerializeWith<'a> {
344						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
345						where
346							S: Serializer,
347						{
348							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
349								self.0, serializer,
350							)
351						}
352					}
353					&SerializeWith(&self.r#description)
354				})?;
355			} else {
356				serialize_struct.skip_field("description")?;
357			}
358			if !Vec::is_empty(&self.r#disambiguating_description) {
359				serialize_struct.serialize_field("disambiguatingDescription", {
360					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
361					impl<'a> Serialize for SerializeWith<'a> {
362						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
363						where
364							S: Serializer,
365						{
366							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
367								self.0, serializer,
368							)
369						}
370					}
371					&SerializeWith(&self.r#disambiguating_description)
372				})?;
373			} else {
374				serialize_struct.skip_field("disambiguatingDescription")?;
375			}
376			if !Vec::is_empty(&self.r#identifier) {
377				serialize_struct.serialize_field("identifier", {
378					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
379					impl<'a> Serialize for SerializeWith<'a> {
380						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
381						where
382							S: Serializer,
383						{
384							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
385								self.0, serializer,
386							)
387						}
388					}
389					&SerializeWith(&self.r#identifier)
390				})?;
391			} else {
392				serialize_struct.skip_field("identifier")?;
393			}
394			if !Vec::is_empty(&self.r#image) {
395				serialize_struct.serialize_field("image", {
396					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
397					impl<'a> Serialize for SerializeWith<'a> {
398						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
399						where
400							S: Serializer,
401						{
402							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
403								self.0, serializer,
404							)
405						}
406					}
407					&SerializeWith(&self.r#image)
408				})?;
409			} else {
410				serialize_struct.skip_field("image")?;
411			}
412			if !Vec::is_empty(&self.r#main_entity_of_page) {
413				serialize_struct.serialize_field("mainEntityOfPage", {
414					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
415					impl<'a> Serialize for SerializeWith<'a> {
416						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
417						where
418							S: Serializer,
419						{
420							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
421								self.0, serializer,
422							)
423						}
424					}
425					&SerializeWith(&self.r#main_entity_of_page)
426				})?;
427			} else {
428				serialize_struct.skip_field("mainEntityOfPage")?;
429			}
430			if !Vec::is_empty(&self.r#name) {
431				serialize_struct.serialize_field("name", {
432					struct SerializeWith<'a>(&'a Vec<NameProperty>);
433					impl<'a> Serialize for SerializeWith<'a> {
434						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
435						where
436							S: Serializer,
437						{
438							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
439								self.0, serializer,
440							)
441						}
442					}
443					&SerializeWith(&self.r#name)
444				})?;
445			} else {
446				serialize_struct.skip_field("name")?;
447			}
448			if !Vec::is_empty(&self.r#potential_action) {
449				serialize_struct.serialize_field("potentialAction", {
450					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
451					impl<'a> Serialize for SerializeWith<'a> {
452						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
453						where
454							S: Serializer,
455						{
456							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
457								self.0, serializer,
458							)
459						}
460					}
461					&SerializeWith(&self.r#potential_action)
462				})?;
463			} else {
464				serialize_struct.skip_field("potentialAction")?;
465			}
466			if !Vec::is_empty(&self.r#same_as) {
467				serialize_struct.serialize_field("sameAs", {
468					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
469					impl<'a> Serialize for SerializeWith<'a> {
470						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
471						where
472							S: Serializer,
473						{
474							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
475								self.0, serializer,
476							)
477						}
478					}
479					&SerializeWith(&self.r#same_as)
480				})?;
481			} else {
482				serialize_struct.skip_field("sameAs")?;
483			}
484			if !Vec::is_empty(&self.r#subject_of) {
485				serialize_struct.serialize_field("subjectOf", {
486					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
487					impl<'a> Serialize for SerializeWith<'a> {
488						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
489						where
490							S: Serializer,
491						{
492							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
493								self.0, serializer,
494							)
495						}
496					}
497					&SerializeWith(&self.r#subject_of)
498				})?;
499			} else {
500				serialize_struct.skip_field("subjectOf")?;
501			}
502			if !Vec::is_empty(&self.r#url) {
503				serialize_struct.serialize_field("url", {
504					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
505					impl<'a> Serialize for SerializeWith<'a> {
506						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
507						where
508							S: Serializer,
509						{
510							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
511								self.0, serializer,
512							)
513						}
514					}
515					&SerializeWith(&self.r#url)
516				})?;
517			} else {
518				serialize_struct.skip_field("url")?;
519			}
520			serialize_struct.end()
521		}
522	}
523	impl<'de> Deserialize<'de> for EndorsementRating {
524		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
525		where
526			D: Deserializer<'de>,
527		{
528			enum Field {
529				Author,
530				BestRating,
531				RatingExplanation,
532				RatingValue,
533				ReviewAspect,
534				WorstRating,
535				AdditionalType,
536				AlternateName,
537				Description,
538				DisambiguatingDescription,
539				Identifier,
540				Image,
541				MainEntityOfPage,
542				Name,
543				PotentialAction,
544				SameAs,
545				SubjectOf,
546				Url,
547				Ignore,
548			}
549			struct FieldVisitor;
550			impl<'de> Visitor<'de> for FieldVisitor {
551				type Value = Field;
552				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
553					formatter.write_str("field identifier")
554				}
555				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
556				where
557					E: de::Error,
558				{
559					match value {
560						"author" => Ok(Field::Author),
561						"bestRating" => Ok(Field::BestRating),
562						"ratingExplanation" => Ok(Field::RatingExplanation),
563						"ratingValue" => Ok(Field::RatingValue),
564						"reviewAspect" => Ok(Field::ReviewAspect),
565						"worstRating" => Ok(Field::WorstRating),
566						"additionalType" => Ok(Field::AdditionalType),
567						"alternateName" => Ok(Field::AlternateName),
568						"description" => Ok(Field::Description),
569						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
570						"identifier" => Ok(Field::Identifier),
571						"image" => Ok(Field::Image),
572						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
573						"name" => Ok(Field::Name),
574						"potentialAction" => Ok(Field::PotentialAction),
575						"sameAs" => Ok(Field::SameAs),
576						"subjectOf" => Ok(Field::SubjectOf),
577						"url" => Ok(Field::Url),
578						"id" | "type" => Ok(Field::Ignore),
579						_ => Err(de::Error::unknown_field(value, FIELDS)),
580					}
581				}
582				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
583				where
584					E: de::Error,
585				{
586					match value {
587						b"author" => Ok(Field::Author),
588						b"bestRating" => Ok(Field::BestRating),
589						b"ratingExplanation" => Ok(Field::RatingExplanation),
590						b"ratingValue" => Ok(Field::RatingValue),
591						b"reviewAspect" => Ok(Field::ReviewAspect),
592						b"worstRating" => Ok(Field::WorstRating),
593						b"additionalType" => Ok(Field::AdditionalType),
594						b"alternateName" => Ok(Field::AlternateName),
595						b"description" => Ok(Field::Description),
596						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
597						b"identifier" => Ok(Field::Identifier),
598						b"image" => Ok(Field::Image),
599						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
600						b"name" => Ok(Field::Name),
601						b"potentialAction" => Ok(Field::PotentialAction),
602						b"sameAs" => Ok(Field::SameAs),
603						b"subjectOf" => Ok(Field::SubjectOf),
604						b"url" => Ok(Field::Url),
605						b"id" | b"type" => Ok(Field::Ignore),
606						_ => {
607							let value = &String::from_utf8_lossy(value);
608							Err(de::Error::unknown_field(value, FIELDS))
609						}
610					}
611				}
612			}
613			impl<'de> Deserialize<'de> for Field {
614				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
615				where
616					D: Deserializer<'de>,
617				{
618					deserializer.deserialize_identifier(FieldVisitor)
619				}
620			}
621			struct ClassVisitor;
622			impl<'de> Visitor<'de> for ClassVisitor {
623				type Value = EndorsementRating;
624				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
625					formatter.write_str("schema.org schema EndorsementRating")
626				}
627				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
628				where
629					A: de::MapAccess<'de>,
630				{
631					let mut r#author_property = None;
632					let mut r#best_rating_property = None;
633					let mut r#rating_explanation_property = None;
634					let mut r#rating_value_property = None;
635					let mut r#review_aspect_property = None;
636					let mut r#worst_rating_property = None;
637					let mut r#additional_type_property = None;
638					let mut r#alternate_name_property = None;
639					let mut r#description_property = None;
640					let mut r#disambiguating_description_property = None;
641					let mut r#identifier_property = None;
642					let mut r#image_property = None;
643					let mut r#main_entity_of_page_property = None;
644					let mut r#name_property = None;
645					let mut r#potential_action_property = None;
646					let mut r#same_as_property = None;
647					let mut r#subject_of_property = None;
648					let mut r#url_property = None;
649					while let Some(key) = map.next_key::<Field>()? {
650						match key {
651							Field::Author => {
652								if r#author_property.is_some() {
653									return Err(<A::Error as de::Error>::duplicate_field("author"));
654								}
655								r#author_property = Some({
656									struct DeserializeWith(Vec<AuthorProperty>);
657									impl<'de> Deserialize<'de> for DeserializeWith {
658										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
659										where
660											D: Deserializer<'de>,
661										{
662											Ok(DeserializeWith(serde_with::As::<
663												serde_with::OneOrMany<serde_with::Same>,
664											>::deserialize(deserializer)?))
665										}
666									}
667									match map.next_value::<DeserializeWith>() {
668										Ok(deserialize_with) => deserialize_with.0,
669										Err(err) => {
670											return Err(err);
671										}
672									}
673								});
674							}
675							Field::BestRating => {
676								if r#best_rating_property.is_some() {
677									return Err(<A::Error as de::Error>::duplicate_field(
678										"bestRating",
679									));
680								}
681								r#best_rating_property = Some({
682									struct DeserializeWith(Vec<BestRatingProperty>);
683									impl<'de> Deserialize<'de> for DeserializeWith {
684										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
685										where
686											D: Deserializer<'de>,
687										{
688											Ok(DeserializeWith(serde_with::As::<
689												serde_with::OneOrMany<serde_with::Same>,
690											>::deserialize(deserializer)?))
691										}
692									}
693									match map.next_value::<DeserializeWith>() {
694										Ok(deserialize_with) => deserialize_with.0,
695										Err(err) => {
696											return Err(err);
697										}
698									}
699								});
700							}
701							Field::RatingExplanation => {
702								if r#rating_explanation_property.is_some() {
703									return Err(<A::Error as de::Error>::duplicate_field(
704										"ratingExplanation",
705									));
706								}
707								r#rating_explanation_property = Some({
708									struct DeserializeWith(Vec<RatingExplanationProperty>);
709									impl<'de> Deserialize<'de> for DeserializeWith {
710										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
711										where
712											D: Deserializer<'de>,
713										{
714											Ok(DeserializeWith(serde_with::As::<
715												serde_with::OneOrMany<serde_with::Same>,
716											>::deserialize(deserializer)?))
717										}
718									}
719									match map.next_value::<DeserializeWith>() {
720										Ok(deserialize_with) => deserialize_with.0,
721										Err(err) => {
722											return Err(err);
723										}
724									}
725								});
726							}
727							Field::RatingValue => {
728								if r#rating_value_property.is_some() {
729									return Err(<A::Error as de::Error>::duplicate_field(
730										"ratingValue",
731									));
732								}
733								r#rating_value_property = Some({
734									struct DeserializeWith(Vec<RatingValueProperty>);
735									impl<'de> Deserialize<'de> for DeserializeWith {
736										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
737										where
738											D: Deserializer<'de>,
739										{
740											Ok(DeserializeWith(serde_with::As::<
741												serde_with::OneOrMany<serde_with::Same>,
742											>::deserialize(deserializer)?))
743										}
744									}
745									match map.next_value::<DeserializeWith>() {
746										Ok(deserialize_with) => deserialize_with.0,
747										Err(err) => {
748											return Err(err);
749										}
750									}
751								});
752							}
753							Field::ReviewAspect => {
754								if r#review_aspect_property.is_some() {
755									return Err(<A::Error as de::Error>::duplicate_field(
756										"reviewAspect",
757									));
758								}
759								r#review_aspect_property = Some({
760									struct DeserializeWith(Vec<ReviewAspectProperty>);
761									impl<'de> Deserialize<'de> for DeserializeWith {
762										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
763										where
764											D: Deserializer<'de>,
765										{
766											Ok(DeserializeWith(serde_with::As::<
767												serde_with::OneOrMany<serde_with::Same>,
768											>::deserialize(deserializer)?))
769										}
770									}
771									match map.next_value::<DeserializeWith>() {
772										Ok(deserialize_with) => deserialize_with.0,
773										Err(err) => {
774											return Err(err);
775										}
776									}
777								});
778							}
779							Field::WorstRating => {
780								if r#worst_rating_property.is_some() {
781									return Err(<A::Error as de::Error>::duplicate_field(
782										"worstRating",
783									));
784								}
785								r#worst_rating_property = Some({
786									struct DeserializeWith(Vec<WorstRatingProperty>);
787									impl<'de> Deserialize<'de> for DeserializeWith {
788										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
789										where
790											D: Deserializer<'de>,
791										{
792											Ok(DeserializeWith(serde_with::As::<
793												serde_with::OneOrMany<serde_with::Same>,
794											>::deserialize(deserializer)?))
795										}
796									}
797									match map.next_value::<DeserializeWith>() {
798										Ok(deserialize_with) => deserialize_with.0,
799										Err(err) => {
800											return Err(err);
801										}
802									}
803								});
804							}
805							Field::AdditionalType => {
806								if r#additional_type_property.is_some() {
807									return Err(<A::Error as de::Error>::duplicate_field(
808										"additionalType",
809									));
810								}
811								r#additional_type_property = Some({
812									struct DeserializeWith(Vec<AdditionalTypeProperty>);
813									impl<'de> Deserialize<'de> for DeserializeWith {
814										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
815										where
816											D: Deserializer<'de>,
817										{
818											Ok(DeserializeWith(serde_with::As::<
819												serde_with::OneOrMany<serde_with::Same>,
820											>::deserialize(deserializer)?))
821										}
822									}
823									match map.next_value::<DeserializeWith>() {
824										Ok(deserialize_with) => deserialize_with.0,
825										Err(err) => {
826											return Err(err);
827										}
828									}
829								});
830							}
831							Field::AlternateName => {
832								if r#alternate_name_property.is_some() {
833									return Err(<A::Error as de::Error>::duplicate_field(
834										"alternateName",
835									));
836								}
837								r#alternate_name_property = Some({
838									struct DeserializeWith(Vec<AlternateNameProperty>);
839									impl<'de> Deserialize<'de> for DeserializeWith {
840										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
841										where
842											D: Deserializer<'de>,
843										{
844											Ok(DeserializeWith(serde_with::As::<
845												serde_with::OneOrMany<serde_with::Same>,
846											>::deserialize(deserializer)?))
847										}
848									}
849									match map.next_value::<DeserializeWith>() {
850										Ok(deserialize_with) => deserialize_with.0,
851										Err(err) => {
852											return Err(err);
853										}
854									}
855								});
856							}
857							Field::Description => {
858								if r#description_property.is_some() {
859									return Err(<A::Error as de::Error>::duplicate_field(
860										"description",
861									));
862								}
863								r#description_property = Some({
864									struct DeserializeWith(Vec<DescriptionProperty>);
865									impl<'de> Deserialize<'de> for DeserializeWith {
866										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
867										where
868											D: Deserializer<'de>,
869										{
870											Ok(DeserializeWith(serde_with::As::<
871												serde_with::OneOrMany<serde_with::Same>,
872											>::deserialize(deserializer)?))
873										}
874									}
875									match map.next_value::<DeserializeWith>() {
876										Ok(deserialize_with) => deserialize_with.0,
877										Err(err) => {
878											return Err(err);
879										}
880									}
881								});
882							}
883							Field::DisambiguatingDescription => {
884								if r#disambiguating_description_property.is_some() {
885									return Err(<A::Error as de::Error>::duplicate_field(
886										"disambiguatingDescription",
887									));
888								}
889								r#disambiguating_description_property = Some({
890									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
891									impl<'de> Deserialize<'de> for DeserializeWith {
892										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
893										where
894											D: Deserializer<'de>,
895										{
896											Ok(DeserializeWith(serde_with::As::<
897												serde_with::OneOrMany<serde_with::Same>,
898											>::deserialize(deserializer)?))
899										}
900									}
901									match map.next_value::<DeserializeWith>() {
902										Ok(deserialize_with) => deserialize_with.0,
903										Err(err) => {
904											return Err(err);
905										}
906									}
907								});
908							}
909							Field::Identifier => {
910								if r#identifier_property.is_some() {
911									return Err(<A::Error as de::Error>::duplicate_field(
912										"identifier",
913									));
914								}
915								r#identifier_property = Some({
916									struct DeserializeWith(Vec<IdentifierProperty>);
917									impl<'de> Deserialize<'de> for DeserializeWith {
918										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
919										where
920											D: Deserializer<'de>,
921										{
922											Ok(DeserializeWith(serde_with::As::<
923												serde_with::OneOrMany<serde_with::Same>,
924											>::deserialize(deserializer)?))
925										}
926									}
927									match map.next_value::<DeserializeWith>() {
928										Ok(deserialize_with) => deserialize_with.0,
929										Err(err) => {
930											return Err(err);
931										}
932									}
933								});
934							}
935							Field::Image => {
936								if r#image_property.is_some() {
937									return Err(<A::Error as de::Error>::duplicate_field("image"));
938								}
939								r#image_property = Some({
940									struct DeserializeWith(Vec<ImageProperty>);
941									impl<'de> Deserialize<'de> for DeserializeWith {
942										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
943										where
944											D: Deserializer<'de>,
945										{
946											Ok(DeserializeWith(serde_with::As::<
947												serde_with::OneOrMany<serde_with::Same>,
948											>::deserialize(deserializer)?))
949										}
950									}
951									match map.next_value::<DeserializeWith>() {
952										Ok(deserialize_with) => deserialize_with.0,
953										Err(err) => {
954											return Err(err);
955										}
956									}
957								});
958							}
959							Field::MainEntityOfPage => {
960								if r#main_entity_of_page_property.is_some() {
961									return Err(<A::Error as de::Error>::duplicate_field(
962										"mainEntityOfPage",
963									));
964								}
965								r#main_entity_of_page_property = Some({
966									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
967									impl<'de> Deserialize<'de> for DeserializeWith {
968										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
969										where
970											D: Deserializer<'de>,
971										{
972											Ok(DeserializeWith(serde_with::As::<
973												serde_with::OneOrMany<serde_with::Same>,
974											>::deserialize(deserializer)?))
975										}
976									}
977									match map.next_value::<DeserializeWith>() {
978										Ok(deserialize_with) => deserialize_with.0,
979										Err(err) => {
980											return Err(err);
981										}
982									}
983								});
984							}
985							Field::Name => {
986								if r#name_property.is_some() {
987									return Err(<A::Error as de::Error>::duplicate_field("name"));
988								}
989								r#name_property = Some({
990									struct DeserializeWith(Vec<NameProperty>);
991									impl<'de> Deserialize<'de> for DeserializeWith {
992										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
993										where
994											D: Deserializer<'de>,
995										{
996											Ok(DeserializeWith(serde_with::As::<
997												serde_with::OneOrMany<serde_with::Same>,
998											>::deserialize(deserializer)?))
999										}
1000									}
1001									match map.next_value::<DeserializeWith>() {
1002										Ok(deserialize_with) => deserialize_with.0,
1003										Err(err) => {
1004											return Err(err);
1005										}
1006									}
1007								});
1008							}
1009							Field::PotentialAction => {
1010								if r#potential_action_property.is_some() {
1011									return Err(<A::Error as de::Error>::duplicate_field(
1012										"potentialAction",
1013									));
1014								}
1015								r#potential_action_property = Some({
1016									struct DeserializeWith(Vec<PotentialActionProperty>);
1017									impl<'de> Deserialize<'de> for DeserializeWith {
1018										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1019										where
1020											D: Deserializer<'de>,
1021										{
1022											Ok(DeserializeWith(serde_with::As::<
1023												serde_with::OneOrMany<serde_with::Same>,
1024											>::deserialize(deserializer)?))
1025										}
1026									}
1027									match map.next_value::<DeserializeWith>() {
1028										Ok(deserialize_with) => deserialize_with.0,
1029										Err(err) => {
1030											return Err(err);
1031										}
1032									}
1033								});
1034							}
1035							Field::SameAs => {
1036								if r#same_as_property.is_some() {
1037									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1038								}
1039								r#same_as_property = Some({
1040									struct DeserializeWith(Vec<SameAsProperty>);
1041									impl<'de> Deserialize<'de> for DeserializeWith {
1042										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1043										where
1044											D: Deserializer<'de>,
1045										{
1046											Ok(DeserializeWith(serde_with::As::<
1047												serde_with::OneOrMany<serde_with::Same>,
1048											>::deserialize(deserializer)?))
1049										}
1050									}
1051									match map.next_value::<DeserializeWith>() {
1052										Ok(deserialize_with) => deserialize_with.0,
1053										Err(err) => {
1054											return Err(err);
1055										}
1056									}
1057								});
1058							}
1059							Field::SubjectOf => {
1060								if r#subject_of_property.is_some() {
1061									return Err(<A::Error as de::Error>::duplicate_field(
1062										"subjectOf",
1063									));
1064								}
1065								r#subject_of_property = Some({
1066									struct DeserializeWith(Vec<SubjectOfProperty>);
1067									impl<'de> Deserialize<'de> for DeserializeWith {
1068										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1069										where
1070											D: Deserializer<'de>,
1071										{
1072											Ok(DeserializeWith(serde_with::As::<
1073												serde_with::OneOrMany<serde_with::Same>,
1074											>::deserialize(deserializer)?))
1075										}
1076									}
1077									match map.next_value::<DeserializeWith>() {
1078										Ok(deserialize_with) => deserialize_with.0,
1079										Err(err) => {
1080											return Err(err);
1081										}
1082									}
1083								});
1084							}
1085							Field::Url => {
1086								if r#url_property.is_some() {
1087									return Err(<A::Error as de::Error>::duplicate_field("url"));
1088								}
1089								r#url_property = Some({
1090									struct DeserializeWith(Vec<UrlProperty>);
1091									impl<'de> Deserialize<'de> for DeserializeWith {
1092										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1093										where
1094											D: Deserializer<'de>,
1095										{
1096											Ok(DeserializeWith(serde_with::As::<
1097												serde_with::OneOrMany<serde_with::Same>,
1098											>::deserialize(deserializer)?))
1099										}
1100									}
1101									match map.next_value::<DeserializeWith>() {
1102										Ok(deserialize_with) => deserialize_with.0,
1103										Err(err) => {
1104											return Err(err);
1105										}
1106									}
1107								});
1108							}
1109							Field::Ignore => {
1110								let _ = map.next_value::<de::IgnoredAny>()?;
1111							}
1112						}
1113					}
1114					Ok(EndorsementRating {
1115						r#author: r#author_property.unwrap_or_default(),
1116						r#best_rating: r#best_rating_property.unwrap_or_default(),
1117						r#rating_explanation: r#rating_explanation_property.unwrap_or_default(),
1118						r#rating_value: r#rating_value_property.unwrap_or_default(),
1119						r#review_aspect: r#review_aspect_property.unwrap_or_default(),
1120						r#worst_rating: r#worst_rating_property.unwrap_or_default(),
1121						r#additional_type: r#additional_type_property.unwrap_or_default(),
1122						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1123						r#description: r#description_property.unwrap_or_default(),
1124						r#disambiguating_description: r#disambiguating_description_property
1125							.unwrap_or_default(),
1126						r#identifier: r#identifier_property.unwrap_or_default(),
1127						r#image: r#image_property.unwrap_or_default(),
1128						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1129						r#name: r#name_property.unwrap_or_default(),
1130						r#potential_action: r#potential_action_property.unwrap_or_default(),
1131						r#same_as: r#same_as_property.unwrap_or_default(),
1132						r#subject_of: r#subject_of_property.unwrap_or_default(),
1133						r#url: r#url_property.unwrap_or_default(),
1134					})
1135				}
1136			}
1137			const FIELDS: &[&str] = &[
1138				"author",
1139				"bestRating",
1140				"ratingExplanation",
1141				"ratingValue",
1142				"reviewAspect",
1143				"worstRating",
1144				"additionalType",
1145				"alternateName",
1146				"description",
1147				"disambiguatingDescription",
1148				"identifier",
1149				"image",
1150				"mainEntityOfPage",
1151				"name",
1152				"potentialAction",
1153				"sameAs",
1154				"subjectOf",
1155				"url",
1156			];
1157			deserializer.deserialize_struct("EndorsementRating", FIELDS, ClassVisitor)
1158		}
1159	}
1160}
schema_org_types/schemas/classes/endorsement_rating.rs

schema_org_types/schemas/classes/
endorsement_rating.rs
