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