1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Product {
6 pub r#additional_property: Vec<AdditionalPropertyProperty>,
8 pub r#aggregate_rating: Vec<AggregateRatingProperty>,
10 pub r#asin: Vec<AsinProperty>,
12 pub r#audience: Vec<AudienceProperty>,
14 pub r#award: Vec<AwardProperty>,
16 #[deprecated = "This schema is superseded by <https://schema.org/award>."]
18 pub r#awards: Vec<AwardsProperty>,
19 pub r#brand: Vec<BrandProperty>,
21 pub r#category: Vec<CategoryProperty>,
23 pub r#color: Vec<ColorProperty>,
25 pub r#country_of_assembly: Vec<CountryOfAssemblyProperty>,
27 pub r#country_of_last_processing: Vec<CountryOfLastProcessingProperty>,
29 pub r#country_of_origin: Vec<CountryOfOriginProperty>,
31 pub r#depth: Vec<DepthProperty>,
33 pub r#funding: Vec<FundingProperty>,
35 pub r#gtin: Vec<GtinProperty>,
37 pub r#gtin_12: Vec<Gtin12Property>,
39 pub r#gtin_13: Vec<Gtin13Property>,
41 pub r#gtin_14: Vec<Gtin14Property>,
43 pub r#gtin_8: Vec<Gtin8Property>,
45 pub r#has_adult_consideration: Vec<HasAdultConsiderationProperty>,
47 pub r#has_energy_consumption_details: Vec<HasEnergyConsumptionDetailsProperty>,
49 pub r#has_measurement: Vec<HasMeasurementProperty>,
51 pub r#has_merchant_return_policy: Vec<HasMerchantReturnPolicyProperty>,
53 #[deprecated = "This schema is archived, see <https://schema.org/docs/attic.home.html>. This schema is superseded by <https://schema.org/hasMerchantReturnPolicy>."]
55 pub r#has_product_return_policy: Vec<HasProductReturnPolicyProperty>,
56 pub r#height: Vec<HeightProperty>,
58 pub r#in_product_group_with_id: Vec<InProductGroupWithIdProperty>,
60 pub r#is_accessory_or_spare_part_for: Vec<IsAccessoryOrSparePartForProperty>,
62 pub r#is_consumable_for: Vec<IsConsumableForProperty>,
64 pub r#is_family_friendly: Vec<IsFamilyFriendlyProperty>,
66 pub r#is_related_to: Vec<IsRelatedToProperty>,
68 pub r#is_similar_to: Vec<IsSimilarToProperty>,
70 pub r#is_variant_of: Vec<IsVariantOfProperty>,
72 pub r#item_condition: Vec<ItemConditionProperty>,
74 pub r#keywords: Vec<KeywordsProperty>,
76 pub r#logo: Vec<LogoProperty>,
78 pub r#manufacturer: Vec<ManufacturerProperty>,
80 pub r#material: Vec<MaterialProperty>,
82 pub r#mobile_url: Vec<MobileUrlProperty>,
84 pub r#model: Vec<ModelProperty>,
86 pub r#mpn: Vec<MpnProperty>,
88 pub r#negative_notes: Vec<NegativeNotesProperty>,
90 pub r#nsn: Vec<NsnProperty>,
92 pub r#offers: Vec<OffersProperty>,
94 pub r#pattern: Vec<PatternProperty>,
96 pub r#positive_notes: Vec<PositiveNotesProperty>,
98 pub r#product_id: Vec<ProductIdProperty>,
100 pub r#production_date: Vec<ProductionDateProperty>,
102 pub r#purchase_date: Vec<PurchaseDateProperty>,
104 pub r#release_date: Vec<ReleaseDateProperty>,
106 pub r#review: Vec<ReviewProperty>,
108 #[deprecated = "This schema is superseded by <https://schema.org/review>."]
110 pub r#reviews: Vec<ReviewsProperty>,
111 pub r#size: Vec<SizeProperty>,
113 pub r#sku: Vec<SkuProperty>,
115 pub r#slogan: Vec<SloganProperty>,
117 pub r#weight: Vec<WeightProperty>,
119 pub r#width: Vec<WidthProperty>,
121 pub r#additional_type: Vec<AdditionalTypeProperty>,
123 pub r#alternate_name: Vec<AlternateNameProperty>,
125 pub r#description: Vec<DescriptionProperty>,
127 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
129 pub r#identifier: Vec<IdentifierProperty>,
131 pub r#image: Vec<ImageProperty>,
133 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
135 pub r#name: Vec<NameProperty>,
137 pub r#potential_action: Vec<PotentialActionProperty>,
139 pub r#same_as: Vec<SameAsProperty>,
141 pub r#subject_of: Vec<SubjectOfProperty>,
143 pub r#url: Vec<UrlProperty>,
145}
146pub trait ProductTrait {
148 fn get_additional_property(&self) -> &[AdditionalPropertyProperty];
150 fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty>;
152 fn get_aggregate_rating(&self) -> &[AggregateRatingProperty];
154 fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty>;
156 fn get_asin(&self) -> &[AsinProperty];
158 fn take_asin(&mut self) -> Vec<AsinProperty>;
160 fn get_audience(&self) -> &[AudienceProperty];
162 fn take_audience(&mut self) -> Vec<AudienceProperty>;
164 fn get_award(&self) -> &[AwardProperty];
166 fn take_award(&mut self) -> Vec<AwardProperty>;
168 #[deprecated = "This schema is superseded by <https://schema.org/award>."]
170 fn get_awards(&self) -> &[AwardsProperty];
171 #[deprecated = "This schema is superseded by <https://schema.org/award>."]
173 fn take_awards(&mut self) -> Vec<AwardsProperty>;
174 fn get_brand(&self) -> &[BrandProperty];
176 fn take_brand(&mut self) -> Vec<BrandProperty>;
178 fn get_category(&self) -> &[CategoryProperty];
180 fn take_category(&mut self) -> Vec<CategoryProperty>;
182 fn get_color(&self) -> &[ColorProperty];
184 fn take_color(&mut self) -> Vec<ColorProperty>;
186 fn get_country_of_assembly(&self) -> &[CountryOfAssemblyProperty];
188 fn take_country_of_assembly(&mut self) -> Vec<CountryOfAssemblyProperty>;
190 fn get_country_of_last_processing(&self) -> &[CountryOfLastProcessingProperty];
192 fn take_country_of_last_processing(&mut self) -> Vec<CountryOfLastProcessingProperty>;
194 fn get_country_of_origin(&self) -> &[CountryOfOriginProperty];
196 fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty>;
198 fn get_depth(&self) -> &[DepthProperty];
200 fn take_depth(&mut self) -> Vec<DepthProperty>;
202 fn get_funding(&self) -> &[FundingProperty];
204 fn take_funding(&mut self) -> Vec<FundingProperty>;
206 fn get_gtin(&self) -> &[GtinProperty];
208 fn take_gtin(&mut self) -> Vec<GtinProperty>;
210 fn get_gtin_12(&self) -> &[Gtin12Property];
212 fn take_gtin_12(&mut self) -> Vec<Gtin12Property>;
214 fn get_gtin_13(&self) -> &[Gtin13Property];
216 fn take_gtin_13(&mut self) -> Vec<Gtin13Property>;
218 fn get_gtin_14(&self) -> &[Gtin14Property];
220 fn take_gtin_14(&mut self) -> Vec<Gtin14Property>;
222 fn get_gtin_8(&self) -> &[Gtin8Property];
224 fn take_gtin_8(&mut self) -> Vec<Gtin8Property>;
226 fn get_has_adult_consideration(&self) -> &[HasAdultConsiderationProperty];
228 fn take_has_adult_consideration(&mut self) -> Vec<HasAdultConsiderationProperty>;
230 fn get_has_energy_consumption_details(&self) -> &[HasEnergyConsumptionDetailsProperty];
232 fn take_has_energy_consumption_details(&mut self) -> Vec<HasEnergyConsumptionDetailsProperty>;
234 fn get_has_measurement(&self) -> &[HasMeasurementProperty];
236 fn take_has_measurement(&mut self) -> Vec<HasMeasurementProperty>;
238 fn get_has_merchant_return_policy(&self) -> &[HasMerchantReturnPolicyProperty];
240 fn take_has_merchant_return_policy(&mut self) -> Vec<HasMerchantReturnPolicyProperty>;
242 #[deprecated = "This schema is archived, see <https://schema.org/docs/attic.home.html>. This schema is superseded by <https://schema.org/hasMerchantReturnPolicy>."]
244 fn get_has_product_return_policy(&self) -> &[HasProductReturnPolicyProperty];
245 #[deprecated = "This schema is archived, see <https://schema.org/docs/attic.home.html>. This schema is superseded by <https://schema.org/hasMerchantReturnPolicy>."]
247 fn take_has_product_return_policy(&mut self) -> Vec<HasProductReturnPolicyProperty>;
248 fn get_height(&self) -> &[HeightProperty];
250 fn take_height(&mut self) -> Vec<HeightProperty>;
252 fn get_in_product_group_with_id(&self) -> &[InProductGroupWithIdProperty];
254 fn take_in_product_group_with_id(&mut self) -> Vec<InProductGroupWithIdProperty>;
256 fn get_is_accessory_or_spare_part_for(&self) -> &[IsAccessoryOrSparePartForProperty];
258 fn take_is_accessory_or_spare_part_for(&mut self) -> Vec<IsAccessoryOrSparePartForProperty>;
260 fn get_is_consumable_for(&self) -> &[IsConsumableForProperty];
262 fn take_is_consumable_for(&mut self) -> Vec<IsConsumableForProperty>;
264 fn get_is_family_friendly(&self) -> &[IsFamilyFriendlyProperty];
266 fn take_is_family_friendly(&mut self) -> Vec<IsFamilyFriendlyProperty>;
268 fn get_is_related_to(&self) -> &[IsRelatedToProperty];
270 fn take_is_related_to(&mut self) -> Vec<IsRelatedToProperty>;
272 fn get_is_similar_to(&self) -> &[IsSimilarToProperty];
274 fn take_is_similar_to(&mut self) -> Vec<IsSimilarToProperty>;
276 fn get_is_variant_of(&self) -> &[IsVariantOfProperty];
278 fn take_is_variant_of(&mut self) -> Vec<IsVariantOfProperty>;
280 fn get_item_condition(&self) -> &[ItemConditionProperty];
282 fn take_item_condition(&mut self) -> Vec<ItemConditionProperty>;
284 fn get_keywords(&self) -> &[KeywordsProperty];
286 fn take_keywords(&mut self) -> Vec<KeywordsProperty>;
288 fn get_logo(&self) -> &[LogoProperty];
290 fn take_logo(&mut self) -> Vec<LogoProperty>;
292 fn get_manufacturer(&self) -> &[ManufacturerProperty];
294 fn take_manufacturer(&mut self) -> Vec<ManufacturerProperty>;
296 fn get_material(&self) -> &[MaterialProperty];
298 fn take_material(&mut self) -> Vec<MaterialProperty>;
300 fn get_mobile_url(&self) -> &[MobileUrlProperty];
302 fn take_mobile_url(&mut self) -> Vec<MobileUrlProperty>;
304 fn get_model(&self) -> &[ModelProperty];
306 fn take_model(&mut self) -> Vec<ModelProperty>;
308 fn get_mpn(&self) -> &[MpnProperty];
310 fn take_mpn(&mut self) -> Vec<MpnProperty>;
312 fn get_negative_notes(&self) -> &[NegativeNotesProperty];
314 fn take_negative_notes(&mut self) -> Vec<NegativeNotesProperty>;
316 fn get_nsn(&self) -> &[NsnProperty];
318 fn take_nsn(&mut self) -> Vec<NsnProperty>;
320 fn get_offers(&self) -> &[OffersProperty];
322 fn take_offers(&mut self) -> Vec<OffersProperty>;
324 fn get_pattern(&self) -> &[PatternProperty];
326 fn take_pattern(&mut self) -> Vec<PatternProperty>;
328 fn get_positive_notes(&self) -> &[PositiveNotesProperty];
330 fn take_positive_notes(&mut self) -> Vec<PositiveNotesProperty>;
332 fn get_product_id(&self) -> &[ProductIdProperty];
334 fn take_product_id(&mut self) -> Vec<ProductIdProperty>;
336 fn get_production_date(&self) -> &[ProductionDateProperty];
338 fn take_production_date(&mut self) -> Vec<ProductionDateProperty>;
340 fn get_purchase_date(&self) -> &[PurchaseDateProperty];
342 fn take_purchase_date(&mut self) -> Vec<PurchaseDateProperty>;
344 fn get_release_date(&self) -> &[ReleaseDateProperty];
346 fn take_release_date(&mut self) -> Vec<ReleaseDateProperty>;
348 fn get_review(&self) -> &[ReviewProperty];
350 fn take_review(&mut self) -> Vec<ReviewProperty>;
352 #[deprecated = "This schema is superseded by <https://schema.org/review>."]
354 fn get_reviews(&self) -> &[ReviewsProperty];
355 #[deprecated = "This schema is superseded by <https://schema.org/review>."]
357 fn take_reviews(&mut self) -> Vec<ReviewsProperty>;
358 fn get_size(&self) -> &[SizeProperty];
360 fn take_size(&mut self) -> Vec<SizeProperty>;
362 fn get_sku(&self) -> &[SkuProperty];
364 fn take_sku(&mut self) -> Vec<SkuProperty>;
366 fn get_slogan(&self) -> &[SloganProperty];
368 fn take_slogan(&mut self) -> Vec<SloganProperty>;
370 fn get_weight(&self) -> &[WeightProperty];
372 fn take_weight(&mut self) -> Vec<WeightProperty>;
374 fn get_width(&self) -> &[WidthProperty];
376 fn take_width(&mut self) -> Vec<WidthProperty>;
378}
379impl ProductTrait for Product {
380 fn get_additional_property(&self) -> &[AdditionalPropertyProperty] {
381 self.r#additional_property.as_slice()
382 }
383 fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty> {
384 std::mem::take(&mut self.r#additional_property)
385 }
386 fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
387 self.r#aggregate_rating.as_slice()
388 }
389 fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
390 std::mem::take(&mut self.r#aggregate_rating)
391 }
392 fn get_asin(&self) -> &[AsinProperty] {
393 self.r#asin.as_slice()
394 }
395 fn take_asin(&mut self) -> Vec<AsinProperty> {
396 std::mem::take(&mut self.r#asin)
397 }
398 fn get_audience(&self) -> &[AudienceProperty] {
399 self.r#audience.as_slice()
400 }
401 fn take_audience(&mut self) -> Vec<AudienceProperty> {
402 std::mem::take(&mut self.r#audience)
403 }
404 fn get_award(&self) -> &[AwardProperty] {
405 self.r#award.as_slice()
406 }
407 fn take_award(&mut self) -> Vec<AwardProperty> {
408 std::mem::take(&mut self.r#award)
409 }
410 fn get_awards(&self) -> &[AwardsProperty] {
411 self.r#awards.as_slice()
412 }
413 fn take_awards(&mut self) -> Vec<AwardsProperty> {
414 std::mem::take(&mut self.r#awards)
415 }
416 fn get_brand(&self) -> &[BrandProperty] {
417 self.r#brand.as_slice()
418 }
419 fn take_brand(&mut self) -> Vec<BrandProperty> {
420 std::mem::take(&mut self.r#brand)
421 }
422 fn get_category(&self) -> &[CategoryProperty] {
423 self.r#category.as_slice()
424 }
425 fn take_category(&mut self) -> Vec<CategoryProperty> {
426 std::mem::take(&mut self.r#category)
427 }
428 fn get_color(&self) -> &[ColorProperty] {
429 self.r#color.as_slice()
430 }
431 fn take_color(&mut self) -> Vec<ColorProperty> {
432 std::mem::take(&mut self.r#color)
433 }
434 fn get_country_of_assembly(&self) -> &[CountryOfAssemblyProperty] {
435 self.r#country_of_assembly.as_slice()
436 }
437 fn take_country_of_assembly(&mut self) -> Vec<CountryOfAssemblyProperty> {
438 std::mem::take(&mut self.r#country_of_assembly)
439 }
440 fn get_country_of_last_processing(&self) -> &[CountryOfLastProcessingProperty] {
441 self.r#country_of_last_processing.as_slice()
442 }
443 fn take_country_of_last_processing(&mut self) -> Vec<CountryOfLastProcessingProperty> {
444 std::mem::take(&mut self.r#country_of_last_processing)
445 }
446 fn get_country_of_origin(&self) -> &[CountryOfOriginProperty] {
447 self.r#country_of_origin.as_slice()
448 }
449 fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty> {
450 std::mem::take(&mut self.r#country_of_origin)
451 }
452 fn get_depth(&self) -> &[DepthProperty] {
453 self.r#depth.as_slice()
454 }
455 fn take_depth(&mut self) -> Vec<DepthProperty> {
456 std::mem::take(&mut self.r#depth)
457 }
458 fn get_funding(&self) -> &[FundingProperty] {
459 self.r#funding.as_slice()
460 }
461 fn take_funding(&mut self) -> Vec<FundingProperty> {
462 std::mem::take(&mut self.r#funding)
463 }
464 fn get_gtin(&self) -> &[GtinProperty] {
465 self.r#gtin.as_slice()
466 }
467 fn take_gtin(&mut self) -> Vec<GtinProperty> {
468 std::mem::take(&mut self.r#gtin)
469 }
470 fn get_gtin_12(&self) -> &[Gtin12Property] {
471 self.r#gtin_12.as_slice()
472 }
473 fn take_gtin_12(&mut self) -> Vec<Gtin12Property> {
474 std::mem::take(&mut self.r#gtin_12)
475 }
476 fn get_gtin_13(&self) -> &[Gtin13Property] {
477 self.r#gtin_13.as_slice()
478 }
479 fn take_gtin_13(&mut self) -> Vec<Gtin13Property> {
480 std::mem::take(&mut self.r#gtin_13)
481 }
482 fn get_gtin_14(&self) -> &[Gtin14Property] {
483 self.r#gtin_14.as_slice()
484 }
485 fn take_gtin_14(&mut self) -> Vec<Gtin14Property> {
486 std::mem::take(&mut self.r#gtin_14)
487 }
488 fn get_gtin_8(&self) -> &[Gtin8Property] {
489 self.r#gtin_8.as_slice()
490 }
491 fn take_gtin_8(&mut self) -> Vec<Gtin8Property> {
492 std::mem::take(&mut self.r#gtin_8)
493 }
494 fn get_has_adult_consideration(&self) -> &[HasAdultConsiderationProperty] {
495 self.r#has_adult_consideration.as_slice()
496 }
497 fn take_has_adult_consideration(&mut self) -> Vec<HasAdultConsiderationProperty> {
498 std::mem::take(&mut self.r#has_adult_consideration)
499 }
500 fn get_has_energy_consumption_details(&self) -> &[HasEnergyConsumptionDetailsProperty] {
501 self.r#has_energy_consumption_details.as_slice()
502 }
503 fn take_has_energy_consumption_details(&mut self) -> Vec<HasEnergyConsumptionDetailsProperty> {
504 std::mem::take(&mut self.r#has_energy_consumption_details)
505 }
506 fn get_has_measurement(&self) -> &[HasMeasurementProperty] {
507 self.r#has_measurement.as_slice()
508 }
509 fn take_has_measurement(&mut self) -> Vec<HasMeasurementProperty> {
510 std::mem::take(&mut self.r#has_measurement)
511 }
512 fn get_has_merchant_return_policy(&self) -> &[HasMerchantReturnPolicyProperty] {
513 self.r#has_merchant_return_policy.as_slice()
514 }
515 fn take_has_merchant_return_policy(&mut self) -> Vec<HasMerchantReturnPolicyProperty> {
516 std::mem::take(&mut self.r#has_merchant_return_policy)
517 }
518 fn get_has_product_return_policy(&self) -> &[HasProductReturnPolicyProperty] {
519 self.r#has_product_return_policy.as_slice()
520 }
521 fn take_has_product_return_policy(&mut self) -> Vec<HasProductReturnPolicyProperty> {
522 std::mem::take(&mut self.r#has_product_return_policy)
523 }
524 fn get_height(&self) -> &[HeightProperty] {
525 self.r#height.as_slice()
526 }
527 fn take_height(&mut self) -> Vec<HeightProperty> {
528 std::mem::take(&mut self.r#height)
529 }
530 fn get_in_product_group_with_id(&self) -> &[InProductGroupWithIdProperty] {
531 self.r#in_product_group_with_id.as_slice()
532 }
533 fn take_in_product_group_with_id(&mut self) -> Vec<InProductGroupWithIdProperty> {
534 std::mem::take(&mut self.r#in_product_group_with_id)
535 }
536 fn get_is_accessory_or_spare_part_for(&self) -> &[IsAccessoryOrSparePartForProperty] {
537 self.r#is_accessory_or_spare_part_for.as_slice()
538 }
539 fn take_is_accessory_or_spare_part_for(&mut self) -> Vec<IsAccessoryOrSparePartForProperty> {
540 std::mem::take(&mut self.r#is_accessory_or_spare_part_for)
541 }
542 fn get_is_consumable_for(&self) -> &[IsConsumableForProperty] {
543 self.r#is_consumable_for.as_slice()
544 }
545 fn take_is_consumable_for(&mut self) -> Vec<IsConsumableForProperty> {
546 std::mem::take(&mut self.r#is_consumable_for)
547 }
548 fn get_is_family_friendly(&self) -> &[IsFamilyFriendlyProperty] {
549 self.r#is_family_friendly.as_slice()
550 }
551 fn take_is_family_friendly(&mut self) -> Vec<IsFamilyFriendlyProperty> {
552 std::mem::take(&mut self.r#is_family_friendly)
553 }
554 fn get_is_related_to(&self) -> &[IsRelatedToProperty] {
555 self.r#is_related_to.as_slice()
556 }
557 fn take_is_related_to(&mut self) -> Vec<IsRelatedToProperty> {
558 std::mem::take(&mut self.r#is_related_to)
559 }
560 fn get_is_similar_to(&self) -> &[IsSimilarToProperty] {
561 self.r#is_similar_to.as_slice()
562 }
563 fn take_is_similar_to(&mut self) -> Vec<IsSimilarToProperty> {
564 std::mem::take(&mut self.r#is_similar_to)
565 }
566 fn get_is_variant_of(&self) -> &[IsVariantOfProperty] {
567 self.r#is_variant_of.as_slice()
568 }
569 fn take_is_variant_of(&mut self) -> Vec<IsVariantOfProperty> {
570 std::mem::take(&mut self.r#is_variant_of)
571 }
572 fn get_item_condition(&self) -> &[ItemConditionProperty] {
573 self.r#item_condition.as_slice()
574 }
575 fn take_item_condition(&mut self) -> Vec<ItemConditionProperty> {
576 std::mem::take(&mut self.r#item_condition)
577 }
578 fn get_keywords(&self) -> &[KeywordsProperty] {
579 self.r#keywords.as_slice()
580 }
581 fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
582 std::mem::take(&mut self.r#keywords)
583 }
584 fn get_logo(&self) -> &[LogoProperty] {
585 self.r#logo.as_slice()
586 }
587 fn take_logo(&mut self) -> Vec<LogoProperty> {
588 std::mem::take(&mut self.r#logo)
589 }
590 fn get_manufacturer(&self) -> &[ManufacturerProperty] {
591 self.r#manufacturer.as_slice()
592 }
593 fn take_manufacturer(&mut self) -> Vec<ManufacturerProperty> {
594 std::mem::take(&mut self.r#manufacturer)
595 }
596 fn get_material(&self) -> &[MaterialProperty] {
597 self.r#material.as_slice()
598 }
599 fn take_material(&mut self) -> Vec<MaterialProperty> {
600 std::mem::take(&mut self.r#material)
601 }
602 fn get_mobile_url(&self) -> &[MobileUrlProperty] {
603 self.r#mobile_url.as_slice()
604 }
605 fn take_mobile_url(&mut self) -> Vec<MobileUrlProperty> {
606 std::mem::take(&mut self.r#mobile_url)
607 }
608 fn get_model(&self) -> &[ModelProperty] {
609 self.r#model.as_slice()
610 }
611 fn take_model(&mut self) -> Vec<ModelProperty> {
612 std::mem::take(&mut self.r#model)
613 }
614 fn get_mpn(&self) -> &[MpnProperty] {
615 self.r#mpn.as_slice()
616 }
617 fn take_mpn(&mut self) -> Vec<MpnProperty> {
618 std::mem::take(&mut self.r#mpn)
619 }
620 fn get_negative_notes(&self) -> &[NegativeNotesProperty] {
621 self.r#negative_notes.as_slice()
622 }
623 fn take_negative_notes(&mut self) -> Vec<NegativeNotesProperty> {
624 std::mem::take(&mut self.r#negative_notes)
625 }
626 fn get_nsn(&self) -> &[NsnProperty] {
627 self.r#nsn.as_slice()
628 }
629 fn take_nsn(&mut self) -> Vec<NsnProperty> {
630 std::mem::take(&mut self.r#nsn)
631 }
632 fn get_offers(&self) -> &[OffersProperty] {
633 self.r#offers.as_slice()
634 }
635 fn take_offers(&mut self) -> Vec<OffersProperty> {
636 std::mem::take(&mut self.r#offers)
637 }
638 fn get_pattern(&self) -> &[PatternProperty] {
639 self.r#pattern.as_slice()
640 }
641 fn take_pattern(&mut self) -> Vec<PatternProperty> {
642 std::mem::take(&mut self.r#pattern)
643 }
644 fn get_positive_notes(&self) -> &[PositiveNotesProperty] {
645 self.r#positive_notes.as_slice()
646 }
647 fn take_positive_notes(&mut self) -> Vec<PositiveNotesProperty> {
648 std::mem::take(&mut self.r#positive_notes)
649 }
650 fn get_product_id(&self) -> &[ProductIdProperty] {
651 self.r#product_id.as_slice()
652 }
653 fn take_product_id(&mut self) -> Vec<ProductIdProperty> {
654 std::mem::take(&mut self.r#product_id)
655 }
656 fn get_production_date(&self) -> &[ProductionDateProperty] {
657 self.r#production_date.as_slice()
658 }
659 fn take_production_date(&mut self) -> Vec<ProductionDateProperty> {
660 std::mem::take(&mut self.r#production_date)
661 }
662 fn get_purchase_date(&self) -> &[PurchaseDateProperty] {
663 self.r#purchase_date.as_slice()
664 }
665 fn take_purchase_date(&mut self) -> Vec<PurchaseDateProperty> {
666 std::mem::take(&mut self.r#purchase_date)
667 }
668 fn get_release_date(&self) -> &[ReleaseDateProperty] {
669 self.r#release_date.as_slice()
670 }
671 fn take_release_date(&mut self) -> Vec<ReleaseDateProperty> {
672 std::mem::take(&mut self.r#release_date)
673 }
674 fn get_review(&self) -> &[ReviewProperty] {
675 self.r#review.as_slice()
676 }
677 fn take_review(&mut self) -> Vec<ReviewProperty> {
678 std::mem::take(&mut self.r#review)
679 }
680 fn get_reviews(&self) -> &[ReviewsProperty] {
681 self.r#reviews.as_slice()
682 }
683 fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
684 std::mem::take(&mut self.r#reviews)
685 }
686 fn get_size(&self) -> &[SizeProperty] {
687 self.r#size.as_slice()
688 }
689 fn take_size(&mut self) -> Vec<SizeProperty> {
690 std::mem::take(&mut self.r#size)
691 }
692 fn get_sku(&self) -> &[SkuProperty] {
693 self.r#sku.as_slice()
694 }
695 fn take_sku(&mut self) -> Vec<SkuProperty> {
696 std::mem::take(&mut self.r#sku)
697 }
698 fn get_slogan(&self) -> &[SloganProperty] {
699 self.r#slogan.as_slice()
700 }
701 fn take_slogan(&mut self) -> Vec<SloganProperty> {
702 std::mem::take(&mut self.r#slogan)
703 }
704 fn get_weight(&self) -> &[WeightProperty] {
705 self.r#weight.as_slice()
706 }
707 fn take_weight(&mut self) -> Vec<WeightProperty> {
708 std::mem::take(&mut self.r#weight)
709 }
710 fn get_width(&self) -> &[WidthProperty] {
711 self.r#width.as_slice()
712 }
713 fn take_width(&mut self) -> Vec<WidthProperty> {
714 std::mem::take(&mut self.r#width)
715 }
716}
717impl ThingTrait for Product {
718 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
719 self.r#additional_type.as_slice()
720 }
721 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
722 std::mem::take(&mut self.r#additional_type)
723 }
724 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
725 self.r#alternate_name.as_slice()
726 }
727 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
728 std::mem::take(&mut self.r#alternate_name)
729 }
730 fn get_description(&self) -> &[DescriptionProperty] {
731 self.r#description.as_slice()
732 }
733 fn take_description(&mut self) -> Vec<DescriptionProperty> {
734 std::mem::take(&mut self.r#description)
735 }
736 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
737 self.r#disambiguating_description.as_slice()
738 }
739 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
740 std::mem::take(&mut self.r#disambiguating_description)
741 }
742 fn get_identifier(&self) -> &[IdentifierProperty] {
743 self.r#identifier.as_slice()
744 }
745 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
746 std::mem::take(&mut self.r#identifier)
747 }
748 fn get_image(&self) -> &[ImageProperty] {
749 self.r#image.as_slice()
750 }
751 fn take_image(&mut self) -> Vec<ImageProperty> {
752 std::mem::take(&mut self.r#image)
753 }
754 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
755 self.r#main_entity_of_page.as_slice()
756 }
757 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
758 std::mem::take(&mut self.r#main_entity_of_page)
759 }
760 fn get_name(&self) -> &[NameProperty] {
761 self.r#name.as_slice()
762 }
763 fn take_name(&mut self) -> Vec<NameProperty> {
764 std::mem::take(&mut self.r#name)
765 }
766 fn get_potential_action(&self) -> &[PotentialActionProperty] {
767 self.r#potential_action.as_slice()
768 }
769 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
770 std::mem::take(&mut self.r#potential_action)
771 }
772 fn get_same_as(&self) -> &[SameAsProperty] {
773 self.r#same_as.as_slice()
774 }
775 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
776 std::mem::take(&mut self.r#same_as)
777 }
778 fn get_subject_of(&self) -> &[SubjectOfProperty] {
779 self.r#subject_of.as_slice()
780 }
781 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
782 std::mem::take(&mut self.r#subject_of)
783 }
784 fn get_url(&self) -> &[UrlProperty] {
785 self.r#url.as_slice()
786 }
787 fn take_url(&mut self) -> Vec<UrlProperty> {
788 std::mem::take(&mut self.r#url)
789 }
790}
791#[cfg(feature = "serde")]
792mod serde {
793 use std::{fmt, fmt::Formatter};
794
795 use ::serde::{
796 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
797 };
798
799 use super::*;
800 impl Serialize for Product {
801 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
802 where
803 S: Serializer,
804 {
805 let len: usize = [
806 !Vec::is_empty(&self.r#additional_property) as usize,
807 !Vec::is_empty(&self.r#aggregate_rating) as usize,
808 !Vec::is_empty(&self.r#asin) as usize,
809 !Vec::is_empty(&self.r#audience) as usize,
810 !Vec::is_empty(&self.r#award) as usize,
811 !Vec::is_empty(&self.r#awards) as usize,
812 !Vec::is_empty(&self.r#brand) as usize,
813 !Vec::is_empty(&self.r#category) as usize,
814 !Vec::is_empty(&self.r#color) as usize,
815 !Vec::is_empty(&self.r#country_of_assembly) as usize,
816 !Vec::is_empty(&self.r#country_of_last_processing) as usize,
817 !Vec::is_empty(&self.r#country_of_origin) as usize,
818 !Vec::is_empty(&self.r#depth) as usize,
819 !Vec::is_empty(&self.r#funding) as usize,
820 !Vec::is_empty(&self.r#gtin) as usize,
821 !Vec::is_empty(&self.r#gtin_12) as usize,
822 !Vec::is_empty(&self.r#gtin_13) as usize,
823 !Vec::is_empty(&self.r#gtin_14) as usize,
824 !Vec::is_empty(&self.r#gtin_8) as usize,
825 !Vec::is_empty(&self.r#has_adult_consideration) as usize,
826 !Vec::is_empty(&self.r#has_energy_consumption_details) as usize,
827 !Vec::is_empty(&self.r#has_measurement) as usize,
828 !Vec::is_empty(&self.r#has_merchant_return_policy) as usize,
829 !Vec::is_empty(&self.r#has_product_return_policy) as usize,
830 !Vec::is_empty(&self.r#height) as usize,
831 !Vec::is_empty(&self.r#in_product_group_with_id) as usize,
832 !Vec::is_empty(&self.r#is_accessory_or_spare_part_for) as usize,
833 !Vec::is_empty(&self.r#is_consumable_for) as usize,
834 !Vec::is_empty(&self.r#is_family_friendly) as usize,
835 !Vec::is_empty(&self.r#is_related_to) as usize,
836 !Vec::is_empty(&self.r#is_similar_to) as usize,
837 !Vec::is_empty(&self.r#is_variant_of) as usize,
838 !Vec::is_empty(&self.r#item_condition) as usize,
839 !Vec::is_empty(&self.r#keywords) as usize,
840 !Vec::is_empty(&self.r#logo) as usize,
841 !Vec::is_empty(&self.r#manufacturer) as usize,
842 !Vec::is_empty(&self.r#material) as usize,
843 !Vec::is_empty(&self.r#mobile_url) as usize,
844 !Vec::is_empty(&self.r#model) as usize,
845 !Vec::is_empty(&self.r#mpn) as usize,
846 !Vec::is_empty(&self.r#negative_notes) as usize,
847 !Vec::is_empty(&self.r#nsn) as usize,
848 !Vec::is_empty(&self.r#offers) as usize,
849 !Vec::is_empty(&self.r#pattern) as usize,
850 !Vec::is_empty(&self.r#positive_notes) as usize,
851 !Vec::is_empty(&self.r#product_id) as usize,
852 !Vec::is_empty(&self.r#production_date) as usize,
853 !Vec::is_empty(&self.r#purchase_date) as usize,
854 !Vec::is_empty(&self.r#release_date) as usize,
855 !Vec::is_empty(&self.r#review) as usize,
856 !Vec::is_empty(&self.r#reviews) as usize,
857 !Vec::is_empty(&self.r#size) as usize,
858 !Vec::is_empty(&self.r#sku) as usize,
859 !Vec::is_empty(&self.r#slogan) as usize,
860 !Vec::is_empty(&self.r#weight) as usize,
861 !Vec::is_empty(&self.r#width) as usize,
862 !Vec::is_empty(&self.r#additional_type) as usize,
863 !Vec::is_empty(&self.r#alternate_name) as usize,
864 !Vec::is_empty(&self.r#description) as usize,
865 !Vec::is_empty(&self.r#disambiguating_description) as usize,
866 !Vec::is_empty(&self.r#identifier) as usize,
867 !Vec::is_empty(&self.r#image) as usize,
868 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
869 !Vec::is_empty(&self.r#name) as usize,
870 !Vec::is_empty(&self.r#potential_action) as usize,
871 !Vec::is_empty(&self.r#same_as) as usize,
872 !Vec::is_empty(&self.r#subject_of) as usize,
873 !Vec::is_empty(&self.r#url) as usize,
874 ]
875 .iter()
876 .sum();
877 let mut serialize_struct = Serializer::serialize_struct(serializer, "Product", len)?;
878 if !Vec::is_empty(&self.r#additional_property) {
879 serialize_struct.serialize_field("additionalProperty", {
880 struct SerializeWith<'a>(&'a Vec<AdditionalPropertyProperty>);
881 impl<'a> Serialize for SerializeWith<'a> {
882 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
883 where
884 S: Serializer,
885 {
886 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
887 self.0, serializer,
888 )
889 }
890 }
891 &SerializeWith(&self.r#additional_property)
892 })?;
893 } else {
894 serialize_struct.skip_field("additionalProperty")?;
895 }
896 if !Vec::is_empty(&self.r#aggregate_rating) {
897 serialize_struct.serialize_field("aggregateRating", {
898 struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
899 impl<'a> Serialize for SerializeWith<'a> {
900 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
901 where
902 S: Serializer,
903 {
904 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
905 self.0, serializer,
906 )
907 }
908 }
909 &SerializeWith(&self.r#aggregate_rating)
910 })?;
911 } else {
912 serialize_struct.skip_field("aggregateRating")?;
913 }
914 if !Vec::is_empty(&self.r#asin) {
915 serialize_struct.serialize_field("asin", {
916 struct SerializeWith<'a>(&'a Vec<AsinProperty>);
917 impl<'a> Serialize for SerializeWith<'a> {
918 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
919 where
920 S: Serializer,
921 {
922 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
923 self.0, serializer,
924 )
925 }
926 }
927 &SerializeWith(&self.r#asin)
928 })?;
929 } else {
930 serialize_struct.skip_field("asin")?;
931 }
932 if !Vec::is_empty(&self.r#audience) {
933 serialize_struct.serialize_field("audience", {
934 struct SerializeWith<'a>(&'a Vec<AudienceProperty>);
935 impl<'a> Serialize for SerializeWith<'a> {
936 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
937 where
938 S: Serializer,
939 {
940 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
941 self.0, serializer,
942 )
943 }
944 }
945 &SerializeWith(&self.r#audience)
946 })?;
947 } else {
948 serialize_struct.skip_field("audience")?;
949 }
950 if !Vec::is_empty(&self.r#award) {
951 serialize_struct.serialize_field("award", {
952 struct SerializeWith<'a>(&'a Vec<AwardProperty>);
953 impl<'a> Serialize for SerializeWith<'a> {
954 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
955 where
956 S: Serializer,
957 {
958 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
959 self.0, serializer,
960 )
961 }
962 }
963 &SerializeWith(&self.r#award)
964 })?;
965 } else {
966 serialize_struct.skip_field("award")?;
967 }
968 if !Vec::is_empty(&self.r#awards) {
969 serialize_struct.serialize_field("awards", {
970 struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
971 impl<'a> Serialize for SerializeWith<'a> {
972 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
973 where
974 S: Serializer,
975 {
976 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
977 self.0, serializer,
978 )
979 }
980 }
981 &SerializeWith(&self.r#awards)
982 })?;
983 } else {
984 serialize_struct.skip_field("awards")?;
985 }
986 if !Vec::is_empty(&self.r#brand) {
987 serialize_struct.serialize_field("brand", {
988 struct SerializeWith<'a>(&'a Vec<BrandProperty>);
989 impl<'a> Serialize for SerializeWith<'a> {
990 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
991 where
992 S: Serializer,
993 {
994 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
995 self.0, serializer,
996 )
997 }
998 }
999 &SerializeWith(&self.r#brand)
1000 })?;
1001 } else {
1002 serialize_struct.skip_field("brand")?;
1003 }
1004 if !Vec::is_empty(&self.r#category) {
1005 serialize_struct.serialize_field("category", {
1006 struct SerializeWith<'a>(&'a Vec<CategoryProperty>);
1007 impl<'a> Serialize for SerializeWith<'a> {
1008 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1009 where
1010 S: Serializer,
1011 {
1012 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1013 self.0, serializer,
1014 )
1015 }
1016 }
1017 &SerializeWith(&self.r#category)
1018 })?;
1019 } else {
1020 serialize_struct.skip_field("category")?;
1021 }
1022 if !Vec::is_empty(&self.r#color) {
1023 serialize_struct.serialize_field("color", {
1024 struct SerializeWith<'a>(&'a Vec<ColorProperty>);
1025 impl<'a> Serialize for SerializeWith<'a> {
1026 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1027 where
1028 S: Serializer,
1029 {
1030 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1031 self.0, serializer,
1032 )
1033 }
1034 }
1035 &SerializeWith(&self.r#color)
1036 })?;
1037 } else {
1038 serialize_struct.skip_field("color")?;
1039 }
1040 if !Vec::is_empty(&self.r#country_of_assembly) {
1041 serialize_struct.serialize_field("countryOfAssembly", {
1042 struct SerializeWith<'a>(&'a Vec<CountryOfAssemblyProperty>);
1043 impl<'a> Serialize for SerializeWith<'a> {
1044 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1045 where
1046 S: Serializer,
1047 {
1048 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1049 self.0, serializer,
1050 )
1051 }
1052 }
1053 &SerializeWith(&self.r#country_of_assembly)
1054 })?;
1055 } else {
1056 serialize_struct.skip_field("countryOfAssembly")?;
1057 }
1058 if !Vec::is_empty(&self.r#country_of_last_processing) {
1059 serialize_struct.serialize_field("countryOfLastProcessing", {
1060 struct SerializeWith<'a>(&'a Vec<CountryOfLastProcessingProperty>);
1061 impl<'a> Serialize for SerializeWith<'a> {
1062 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1063 where
1064 S: Serializer,
1065 {
1066 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1067 self.0, serializer,
1068 )
1069 }
1070 }
1071 &SerializeWith(&self.r#country_of_last_processing)
1072 })?;
1073 } else {
1074 serialize_struct.skip_field("countryOfLastProcessing")?;
1075 }
1076 if !Vec::is_empty(&self.r#country_of_origin) {
1077 serialize_struct.serialize_field("countryOfOrigin", {
1078 struct SerializeWith<'a>(&'a Vec<CountryOfOriginProperty>);
1079 impl<'a> Serialize for SerializeWith<'a> {
1080 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1081 where
1082 S: Serializer,
1083 {
1084 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1085 self.0, serializer,
1086 )
1087 }
1088 }
1089 &SerializeWith(&self.r#country_of_origin)
1090 })?;
1091 } else {
1092 serialize_struct.skip_field("countryOfOrigin")?;
1093 }
1094 if !Vec::is_empty(&self.r#depth) {
1095 serialize_struct.serialize_field("depth", {
1096 struct SerializeWith<'a>(&'a Vec<DepthProperty>);
1097 impl<'a> Serialize for SerializeWith<'a> {
1098 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1099 where
1100 S: Serializer,
1101 {
1102 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1103 self.0, serializer,
1104 )
1105 }
1106 }
1107 &SerializeWith(&self.r#depth)
1108 })?;
1109 } else {
1110 serialize_struct.skip_field("depth")?;
1111 }
1112 if !Vec::is_empty(&self.r#funding) {
1113 serialize_struct.serialize_field("funding", {
1114 struct SerializeWith<'a>(&'a Vec<FundingProperty>);
1115 impl<'a> Serialize for SerializeWith<'a> {
1116 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1117 where
1118 S: Serializer,
1119 {
1120 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1121 self.0, serializer,
1122 )
1123 }
1124 }
1125 &SerializeWith(&self.r#funding)
1126 })?;
1127 } else {
1128 serialize_struct.skip_field("funding")?;
1129 }
1130 if !Vec::is_empty(&self.r#gtin) {
1131 serialize_struct.serialize_field("gtin", {
1132 struct SerializeWith<'a>(&'a Vec<GtinProperty>);
1133 impl<'a> Serialize for SerializeWith<'a> {
1134 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1135 where
1136 S: Serializer,
1137 {
1138 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1139 self.0, serializer,
1140 )
1141 }
1142 }
1143 &SerializeWith(&self.r#gtin)
1144 })?;
1145 } else {
1146 serialize_struct.skip_field("gtin")?;
1147 }
1148 if !Vec::is_empty(&self.r#gtin_12) {
1149 serialize_struct.serialize_field("gtin12", {
1150 struct SerializeWith<'a>(&'a Vec<Gtin12Property>);
1151 impl<'a> Serialize for SerializeWith<'a> {
1152 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1153 where
1154 S: Serializer,
1155 {
1156 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1157 self.0, serializer,
1158 )
1159 }
1160 }
1161 &SerializeWith(&self.r#gtin_12)
1162 })?;
1163 } else {
1164 serialize_struct.skip_field("gtin12")?;
1165 }
1166 if !Vec::is_empty(&self.r#gtin_13) {
1167 serialize_struct.serialize_field("gtin13", {
1168 struct SerializeWith<'a>(&'a Vec<Gtin13Property>);
1169 impl<'a> Serialize for SerializeWith<'a> {
1170 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1171 where
1172 S: Serializer,
1173 {
1174 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1175 self.0, serializer,
1176 )
1177 }
1178 }
1179 &SerializeWith(&self.r#gtin_13)
1180 })?;
1181 } else {
1182 serialize_struct.skip_field("gtin13")?;
1183 }
1184 if !Vec::is_empty(&self.r#gtin_14) {
1185 serialize_struct.serialize_field("gtin14", {
1186 struct SerializeWith<'a>(&'a Vec<Gtin14Property>);
1187 impl<'a> Serialize for SerializeWith<'a> {
1188 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1189 where
1190 S: Serializer,
1191 {
1192 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1193 self.0, serializer,
1194 )
1195 }
1196 }
1197 &SerializeWith(&self.r#gtin_14)
1198 })?;
1199 } else {
1200 serialize_struct.skip_field("gtin14")?;
1201 }
1202 if !Vec::is_empty(&self.r#gtin_8) {
1203 serialize_struct.serialize_field("gtin8", {
1204 struct SerializeWith<'a>(&'a Vec<Gtin8Property>);
1205 impl<'a> Serialize for SerializeWith<'a> {
1206 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1207 where
1208 S: Serializer,
1209 {
1210 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1211 self.0, serializer,
1212 )
1213 }
1214 }
1215 &SerializeWith(&self.r#gtin_8)
1216 })?;
1217 } else {
1218 serialize_struct.skip_field("gtin8")?;
1219 }
1220 if !Vec::is_empty(&self.r#has_adult_consideration) {
1221 serialize_struct.serialize_field("hasAdultConsideration", {
1222 struct SerializeWith<'a>(&'a Vec<HasAdultConsiderationProperty>);
1223 impl<'a> Serialize for SerializeWith<'a> {
1224 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1225 where
1226 S: Serializer,
1227 {
1228 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1229 self.0, serializer,
1230 )
1231 }
1232 }
1233 &SerializeWith(&self.r#has_adult_consideration)
1234 })?;
1235 } else {
1236 serialize_struct.skip_field("hasAdultConsideration")?;
1237 }
1238 if !Vec::is_empty(&self.r#has_energy_consumption_details) {
1239 serialize_struct.serialize_field("hasEnergyConsumptionDetails", {
1240 struct SerializeWith<'a>(&'a Vec<HasEnergyConsumptionDetailsProperty>);
1241 impl<'a> Serialize for SerializeWith<'a> {
1242 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1243 where
1244 S: Serializer,
1245 {
1246 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1247 self.0, serializer,
1248 )
1249 }
1250 }
1251 &SerializeWith(&self.r#has_energy_consumption_details)
1252 })?;
1253 } else {
1254 serialize_struct.skip_field("hasEnergyConsumptionDetails")?;
1255 }
1256 if !Vec::is_empty(&self.r#has_measurement) {
1257 serialize_struct.serialize_field("hasMeasurement", {
1258 struct SerializeWith<'a>(&'a Vec<HasMeasurementProperty>);
1259 impl<'a> Serialize for SerializeWith<'a> {
1260 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1261 where
1262 S: Serializer,
1263 {
1264 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1265 self.0, serializer,
1266 )
1267 }
1268 }
1269 &SerializeWith(&self.r#has_measurement)
1270 })?;
1271 } else {
1272 serialize_struct.skip_field("hasMeasurement")?;
1273 }
1274 if !Vec::is_empty(&self.r#has_merchant_return_policy) {
1275 serialize_struct.serialize_field("hasMerchantReturnPolicy", {
1276 struct SerializeWith<'a>(&'a Vec<HasMerchantReturnPolicyProperty>);
1277 impl<'a> Serialize for SerializeWith<'a> {
1278 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1279 where
1280 S: Serializer,
1281 {
1282 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1283 self.0, serializer,
1284 )
1285 }
1286 }
1287 &SerializeWith(&self.r#has_merchant_return_policy)
1288 })?;
1289 } else {
1290 serialize_struct.skip_field("hasMerchantReturnPolicy")?;
1291 }
1292 if !Vec::is_empty(&self.r#has_product_return_policy) {
1293 serialize_struct.serialize_field("hasProductReturnPolicy", {
1294 struct SerializeWith<'a>(&'a Vec<HasProductReturnPolicyProperty>);
1295 impl<'a> Serialize for SerializeWith<'a> {
1296 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1297 where
1298 S: Serializer,
1299 {
1300 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1301 self.0, serializer,
1302 )
1303 }
1304 }
1305 &SerializeWith(&self.r#has_product_return_policy)
1306 })?;
1307 } else {
1308 serialize_struct.skip_field("hasProductReturnPolicy")?;
1309 }
1310 if !Vec::is_empty(&self.r#height) {
1311 serialize_struct.serialize_field("height", {
1312 struct SerializeWith<'a>(&'a Vec<HeightProperty>);
1313 impl<'a> Serialize for SerializeWith<'a> {
1314 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1315 where
1316 S: Serializer,
1317 {
1318 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1319 self.0, serializer,
1320 )
1321 }
1322 }
1323 &SerializeWith(&self.r#height)
1324 })?;
1325 } else {
1326 serialize_struct.skip_field("height")?;
1327 }
1328 if !Vec::is_empty(&self.r#in_product_group_with_id) {
1329 serialize_struct.serialize_field("inProductGroupWithID", {
1330 struct SerializeWith<'a>(&'a Vec<InProductGroupWithIdProperty>);
1331 impl<'a> Serialize for SerializeWith<'a> {
1332 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1333 where
1334 S: Serializer,
1335 {
1336 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1337 self.0, serializer,
1338 )
1339 }
1340 }
1341 &SerializeWith(&self.r#in_product_group_with_id)
1342 })?;
1343 } else {
1344 serialize_struct.skip_field("inProductGroupWithID")?;
1345 }
1346 if !Vec::is_empty(&self.r#is_accessory_or_spare_part_for) {
1347 serialize_struct.serialize_field("isAccessoryOrSparePartFor", {
1348 struct SerializeWith<'a>(&'a Vec<IsAccessoryOrSparePartForProperty>);
1349 impl<'a> Serialize for SerializeWith<'a> {
1350 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1351 where
1352 S: Serializer,
1353 {
1354 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1355 self.0, serializer,
1356 )
1357 }
1358 }
1359 &SerializeWith(&self.r#is_accessory_or_spare_part_for)
1360 })?;
1361 } else {
1362 serialize_struct.skip_field("isAccessoryOrSparePartFor")?;
1363 }
1364 if !Vec::is_empty(&self.r#is_consumable_for) {
1365 serialize_struct.serialize_field("isConsumableFor", {
1366 struct SerializeWith<'a>(&'a Vec<IsConsumableForProperty>);
1367 impl<'a> Serialize for SerializeWith<'a> {
1368 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1369 where
1370 S: Serializer,
1371 {
1372 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1373 self.0, serializer,
1374 )
1375 }
1376 }
1377 &SerializeWith(&self.r#is_consumable_for)
1378 })?;
1379 } else {
1380 serialize_struct.skip_field("isConsumableFor")?;
1381 }
1382 if !Vec::is_empty(&self.r#is_family_friendly) {
1383 serialize_struct.serialize_field("isFamilyFriendly", {
1384 struct SerializeWith<'a>(&'a Vec<IsFamilyFriendlyProperty>);
1385 impl<'a> Serialize for SerializeWith<'a> {
1386 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1387 where
1388 S: Serializer,
1389 {
1390 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1391 self.0, serializer,
1392 )
1393 }
1394 }
1395 &SerializeWith(&self.r#is_family_friendly)
1396 })?;
1397 } else {
1398 serialize_struct.skip_field("isFamilyFriendly")?;
1399 }
1400 if !Vec::is_empty(&self.r#is_related_to) {
1401 serialize_struct.serialize_field("isRelatedTo", {
1402 struct SerializeWith<'a>(&'a Vec<IsRelatedToProperty>);
1403 impl<'a> Serialize for SerializeWith<'a> {
1404 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1405 where
1406 S: Serializer,
1407 {
1408 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1409 self.0, serializer,
1410 )
1411 }
1412 }
1413 &SerializeWith(&self.r#is_related_to)
1414 })?;
1415 } else {
1416 serialize_struct.skip_field("isRelatedTo")?;
1417 }
1418 if !Vec::is_empty(&self.r#is_similar_to) {
1419 serialize_struct.serialize_field("isSimilarTo", {
1420 struct SerializeWith<'a>(&'a Vec<IsSimilarToProperty>);
1421 impl<'a> Serialize for SerializeWith<'a> {
1422 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1423 where
1424 S: Serializer,
1425 {
1426 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1427 self.0, serializer,
1428 )
1429 }
1430 }
1431 &SerializeWith(&self.r#is_similar_to)
1432 })?;
1433 } else {
1434 serialize_struct.skip_field("isSimilarTo")?;
1435 }
1436 if !Vec::is_empty(&self.r#is_variant_of) {
1437 serialize_struct.serialize_field("isVariantOf", {
1438 struct SerializeWith<'a>(&'a Vec<IsVariantOfProperty>);
1439 impl<'a> Serialize for SerializeWith<'a> {
1440 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1441 where
1442 S: Serializer,
1443 {
1444 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1445 self.0, serializer,
1446 )
1447 }
1448 }
1449 &SerializeWith(&self.r#is_variant_of)
1450 })?;
1451 } else {
1452 serialize_struct.skip_field("isVariantOf")?;
1453 }
1454 if !Vec::is_empty(&self.r#item_condition) {
1455 serialize_struct.serialize_field("itemCondition", {
1456 struct SerializeWith<'a>(&'a Vec<ItemConditionProperty>);
1457 impl<'a> Serialize for SerializeWith<'a> {
1458 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1459 where
1460 S: Serializer,
1461 {
1462 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1463 self.0, serializer,
1464 )
1465 }
1466 }
1467 &SerializeWith(&self.r#item_condition)
1468 })?;
1469 } else {
1470 serialize_struct.skip_field("itemCondition")?;
1471 }
1472 if !Vec::is_empty(&self.r#keywords) {
1473 serialize_struct.serialize_field("keywords", {
1474 struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
1475 impl<'a> Serialize for SerializeWith<'a> {
1476 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1477 where
1478 S: Serializer,
1479 {
1480 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1481 self.0, serializer,
1482 )
1483 }
1484 }
1485 &SerializeWith(&self.r#keywords)
1486 })?;
1487 } else {
1488 serialize_struct.skip_field("keywords")?;
1489 }
1490 if !Vec::is_empty(&self.r#logo) {
1491 serialize_struct.serialize_field("logo", {
1492 struct SerializeWith<'a>(&'a Vec<LogoProperty>);
1493 impl<'a> Serialize for SerializeWith<'a> {
1494 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1495 where
1496 S: Serializer,
1497 {
1498 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1499 self.0, serializer,
1500 )
1501 }
1502 }
1503 &SerializeWith(&self.r#logo)
1504 })?;
1505 } else {
1506 serialize_struct.skip_field("logo")?;
1507 }
1508 if !Vec::is_empty(&self.r#manufacturer) {
1509 serialize_struct.serialize_field("manufacturer", {
1510 struct SerializeWith<'a>(&'a Vec<ManufacturerProperty>);
1511 impl<'a> Serialize for SerializeWith<'a> {
1512 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1513 where
1514 S: Serializer,
1515 {
1516 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1517 self.0, serializer,
1518 )
1519 }
1520 }
1521 &SerializeWith(&self.r#manufacturer)
1522 })?;
1523 } else {
1524 serialize_struct.skip_field("manufacturer")?;
1525 }
1526 if !Vec::is_empty(&self.r#material) {
1527 serialize_struct.serialize_field("material", {
1528 struct SerializeWith<'a>(&'a Vec<MaterialProperty>);
1529 impl<'a> Serialize for SerializeWith<'a> {
1530 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1531 where
1532 S: Serializer,
1533 {
1534 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1535 self.0, serializer,
1536 )
1537 }
1538 }
1539 &SerializeWith(&self.r#material)
1540 })?;
1541 } else {
1542 serialize_struct.skip_field("material")?;
1543 }
1544 if !Vec::is_empty(&self.r#mobile_url) {
1545 serialize_struct.serialize_field("mobileUrl", {
1546 struct SerializeWith<'a>(&'a Vec<MobileUrlProperty>);
1547 impl<'a> Serialize for SerializeWith<'a> {
1548 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1549 where
1550 S: Serializer,
1551 {
1552 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1553 self.0, serializer,
1554 )
1555 }
1556 }
1557 &SerializeWith(&self.r#mobile_url)
1558 })?;
1559 } else {
1560 serialize_struct.skip_field("mobileUrl")?;
1561 }
1562 if !Vec::is_empty(&self.r#model) {
1563 serialize_struct.serialize_field("model", {
1564 struct SerializeWith<'a>(&'a Vec<ModelProperty>);
1565 impl<'a> Serialize for SerializeWith<'a> {
1566 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1567 where
1568 S: Serializer,
1569 {
1570 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1571 self.0, serializer,
1572 )
1573 }
1574 }
1575 &SerializeWith(&self.r#model)
1576 })?;
1577 } else {
1578 serialize_struct.skip_field("model")?;
1579 }
1580 if !Vec::is_empty(&self.r#mpn) {
1581 serialize_struct.serialize_field("mpn", {
1582 struct SerializeWith<'a>(&'a Vec<MpnProperty>);
1583 impl<'a> Serialize for SerializeWith<'a> {
1584 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1585 where
1586 S: Serializer,
1587 {
1588 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1589 self.0, serializer,
1590 )
1591 }
1592 }
1593 &SerializeWith(&self.r#mpn)
1594 })?;
1595 } else {
1596 serialize_struct.skip_field("mpn")?;
1597 }
1598 if !Vec::is_empty(&self.r#negative_notes) {
1599 serialize_struct.serialize_field("negativeNotes", {
1600 struct SerializeWith<'a>(&'a Vec<NegativeNotesProperty>);
1601 impl<'a> Serialize for SerializeWith<'a> {
1602 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1603 where
1604 S: Serializer,
1605 {
1606 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1607 self.0, serializer,
1608 )
1609 }
1610 }
1611 &SerializeWith(&self.r#negative_notes)
1612 })?;
1613 } else {
1614 serialize_struct.skip_field("negativeNotes")?;
1615 }
1616 if !Vec::is_empty(&self.r#nsn) {
1617 serialize_struct.serialize_field("nsn", {
1618 struct SerializeWith<'a>(&'a Vec<NsnProperty>);
1619 impl<'a> Serialize for SerializeWith<'a> {
1620 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1621 where
1622 S: Serializer,
1623 {
1624 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1625 self.0, serializer,
1626 )
1627 }
1628 }
1629 &SerializeWith(&self.r#nsn)
1630 })?;
1631 } else {
1632 serialize_struct.skip_field("nsn")?;
1633 }
1634 if !Vec::is_empty(&self.r#offers) {
1635 serialize_struct.serialize_field("offers", {
1636 struct SerializeWith<'a>(&'a Vec<OffersProperty>);
1637 impl<'a> Serialize for SerializeWith<'a> {
1638 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1639 where
1640 S: Serializer,
1641 {
1642 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1643 self.0, serializer,
1644 )
1645 }
1646 }
1647 &SerializeWith(&self.r#offers)
1648 })?;
1649 } else {
1650 serialize_struct.skip_field("offers")?;
1651 }
1652 if !Vec::is_empty(&self.r#pattern) {
1653 serialize_struct.serialize_field("pattern", {
1654 struct SerializeWith<'a>(&'a Vec<PatternProperty>);
1655 impl<'a> Serialize for SerializeWith<'a> {
1656 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1657 where
1658 S: Serializer,
1659 {
1660 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1661 self.0, serializer,
1662 )
1663 }
1664 }
1665 &SerializeWith(&self.r#pattern)
1666 })?;
1667 } else {
1668 serialize_struct.skip_field("pattern")?;
1669 }
1670 if !Vec::is_empty(&self.r#positive_notes) {
1671 serialize_struct.serialize_field("positiveNotes", {
1672 struct SerializeWith<'a>(&'a Vec<PositiveNotesProperty>);
1673 impl<'a> Serialize for SerializeWith<'a> {
1674 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1675 where
1676 S: Serializer,
1677 {
1678 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1679 self.0, serializer,
1680 )
1681 }
1682 }
1683 &SerializeWith(&self.r#positive_notes)
1684 })?;
1685 } else {
1686 serialize_struct.skip_field("positiveNotes")?;
1687 }
1688 if !Vec::is_empty(&self.r#product_id) {
1689 serialize_struct.serialize_field("productID", {
1690 struct SerializeWith<'a>(&'a Vec<ProductIdProperty>);
1691 impl<'a> Serialize for SerializeWith<'a> {
1692 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1693 where
1694 S: Serializer,
1695 {
1696 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1697 self.0, serializer,
1698 )
1699 }
1700 }
1701 &SerializeWith(&self.r#product_id)
1702 })?;
1703 } else {
1704 serialize_struct.skip_field("productID")?;
1705 }
1706 if !Vec::is_empty(&self.r#production_date) {
1707 serialize_struct.serialize_field("productionDate", {
1708 struct SerializeWith<'a>(&'a Vec<ProductionDateProperty>);
1709 impl<'a> Serialize for SerializeWith<'a> {
1710 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1711 where
1712 S: Serializer,
1713 {
1714 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1715 self.0, serializer,
1716 )
1717 }
1718 }
1719 &SerializeWith(&self.r#production_date)
1720 })?;
1721 } else {
1722 serialize_struct.skip_field("productionDate")?;
1723 }
1724 if !Vec::is_empty(&self.r#purchase_date) {
1725 serialize_struct.serialize_field("purchaseDate", {
1726 struct SerializeWith<'a>(&'a Vec<PurchaseDateProperty>);
1727 impl<'a> Serialize for SerializeWith<'a> {
1728 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1729 where
1730 S: Serializer,
1731 {
1732 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1733 self.0, serializer,
1734 )
1735 }
1736 }
1737 &SerializeWith(&self.r#purchase_date)
1738 })?;
1739 } else {
1740 serialize_struct.skip_field("purchaseDate")?;
1741 }
1742 if !Vec::is_empty(&self.r#release_date) {
1743 serialize_struct.serialize_field("releaseDate", {
1744 struct SerializeWith<'a>(&'a Vec<ReleaseDateProperty>);
1745 impl<'a> Serialize for SerializeWith<'a> {
1746 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1747 where
1748 S: Serializer,
1749 {
1750 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1751 self.0, serializer,
1752 )
1753 }
1754 }
1755 &SerializeWith(&self.r#release_date)
1756 })?;
1757 } else {
1758 serialize_struct.skip_field("releaseDate")?;
1759 }
1760 if !Vec::is_empty(&self.r#review) {
1761 serialize_struct.serialize_field("review", {
1762 struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
1763 impl<'a> Serialize for SerializeWith<'a> {
1764 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1765 where
1766 S: Serializer,
1767 {
1768 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1769 self.0, serializer,
1770 )
1771 }
1772 }
1773 &SerializeWith(&self.r#review)
1774 })?;
1775 } else {
1776 serialize_struct.skip_field("review")?;
1777 }
1778 if !Vec::is_empty(&self.r#reviews) {
1779 serialize_struct.serialize_field("reviews", {
1780 struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
1781 impl<'a> Serialize for SerializeWith<'a> {
1782 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1783 where
1784 S: Serializer,
1785 {
1786 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1787 self.0, serializer,
1788 )
1789 }
1790 }
1791 &SerializeWith(&self.r#reviews)
1792 })?;
1793 } else {
1794 serialize_struct.skip_field("reviews")?;
1795 }
1796 if !Vec::is_empty(&self.r#size) {
1797 serialize_struct.serialize_field("size", {
1798 struct SerializeWith<'a>(&'a Vec<SizeProperty>);
1799 impl<'a> Serialize for SerializeWith<'a> {
1800 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1801 where
1802 S: Serializer,
1803 {
1804 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1805 self.0, serializer,
1806 )
1807 }
1808 }
1809 &SerializeWith(&self.r#size)
1810 })?;
1811 } else {
1812 serialize_struct.skip_field("size")?;
1813 }
1814 if !Vec::is_empty(&self.r#sku) {
1815 serialize_struct.serialize_field("sku", {
1816 struct SerializeWith<'a>(&'a Vec<SkuProperty>);
1817 impl<'a> Serialize for SerializeWith<'a> {
1818 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1819 where
1820 S: Serializer,
1821 {
1822 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1823 self.0, serializer,
1824 )
1825 }
1826 }
1827 &SerializeWith(&self.r#sku)
1828 })?;
1829 } else {
1830 serialize_struct.skip_field("sku")?;
1831 }
1832 if !Vec::is_empty(&self.r#slogan) {
1833 serialize_struct.serialize_field("slogan", {
1834 struct SerializeWith<'a>(&'a Vec<SloganProperty>);
1835 impl<'a> Serialize for SerializeWith<'a> {
1836 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1837 where
1838 S: Serializer,
1839 {
1840 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1841 self.0, serializer,
1842 )
1843 }
1844 }
1845 &SerializeWith(&self.r#slogan)
1846 })?;
1847 } else {
1848 serialize_struct.skip_field("slogan")?;
1849 }
1850 if !Vec::is_empty(&self.r#weight) {
1851 serialize_struct.serialize_field("weight", {
1852 struct SerializeWith<'a>(&'a Vec<WeightProperty>);
1853 impl<'a> Serialize for SerializeWith<'a> {
1854 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1855 where
1856 S: Serializer,
1857 {
1858 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1859 self.0, serializer,
1860 )
1861 }
1862 }
1863 &SerializeWith(&self.r#weight)
1864 })?;
1865 } else {
1866 serialize_struct.skip_field("weight")?;
1867 }
1868 if !Vec::is_empty(&self.r#width) {
1869 serialize_struct.serialize_field("width", {
1870 struct SerializeWith<'a>(&'a Vec<WidthProperty>);
1871 impl<'a> Serialize for SerializeWith<'a> {
1872 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1873 where
1874 S: Serializer,
1875 {
1876 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1877 self.0, serializer,
1878 )
1879 }
1880 }
1881 &SerializeWith(&self.r#width)
1882 })?;
1883 } else {
1884 serialize_struct.skip_field("width")?;
1885 }
1886 if !Vec::is_empty(&self.r#additional_type) {
1887 serialize_struct.serialize_field("additionalType", {
1888 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
1889 impl<'a> Serialize for SerializeWith<'a> {
1890 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1891 where
1892 S: Serializer,
1893 {
1894 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1895 self.0, serializer,
1896 )
1897 }
1898 }
1899 &SerializeWith(&self.r#additional_type)
1900 })?;
1901 } else {
1902 serialize_struct.skip_field("additionalType")?;
1903 }
1904 if !Vec::is_empty(&self.r#alternate_name) {
1905 serialize_struct.serialize_field("alternateName", {
1906 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
1907 impl<'a> Serialize for SerializeWith<'a> {
1908 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1909 where
1910 S: Serializer,
1911 {
1912 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1913 self.0, serializer,
1914 )
1915 }
1916 }
1917 &SerializeWith(&self.r#alternate_name)
1918 })?;
1919 } else {
1920 serialize_struct.skip_field("alternateName")?;
1921 }
1922 if !Vec::is_empty(&self.r#description) {
1923 serialize_struct.serialize_field("description", {
1924 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
1925 impl<'a> Serialize for SerializeWith<'a> {
1926 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1927 where
1928 S: Serializer,
1929 {
1930 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1931 self.0, serializer,
1932 )
1933 }
1934 }
1935 &SerializeWith(&self.r#description)
1936 })?;
1937 } else {
1938 serialize_struct.skip_field("description")?;
1939 }
1940 if !Vec::is_empty(&self.r#disambiguating_description) {
1941 serialize_struct.serialize_field("disambiguatingDescription", {
1942 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
1943 impl<'a> Serialize for SerializeWith<'a> {
1944 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1945 where
1946 S: Serializer,
1947 {
1948 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1949 self.0, serializer,
1950 )
1951 }
1952 }
1953 &SerializeWith(&self.r#disambiguating_description)
1954 })?;
1955 } else {
1956 serialize_struct.skip_field("disambiguatingDescription")?;
1957 }
1958 if !Vec::is_empty(&self.r#identifier) {
1959 serialize_struct.serialize_field("identifier", {
1960 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
1961 impl<'a> Serialize for SerializeWith<'a> {
1962 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1963 where
1964 S: Serializer,
1965 {
1966 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1967 self.0, serializer,
1968 )
1969 }
1970 }
1971 &SerializeWith(&self.r#identifier)
1972 })?;
1973 } else {
1974 serialize_struct.skip_field("identifier")?;
1975 }
1976 if !Vec::is_empty(&self.r#image) {
1977 serialize_struct.serialize_field("image", {
1978 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
1979 impl<'a> Serialize for SerializeWith<'a> {
1980 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1981 where
1982 S: Serializer,
1983 {
1984 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1985 self.0, serializer,
1986 )
1987 }
1988 }
1989 &SerializeWith(&self.r#image)
1990 })?;
1991 } else {
1992 serialize_struct.skip_field("image")?;
1993 }
1994 if !Vec::is_empty(&self.r#main_entity_of_page) {
1995 serialize_struct.serialize_field("mainEntityOfPage", {
1996 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
1997 impl<'a> Serialize for SerializeWith<'a> {
1998 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1999 where
2000 S: Serializer,
2001 {
2002 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2003 self.0, serializer,
2004 )
2005 }
2006 }
2007 &SerializeWith(&self.r#main_entity_of_page)
2008 })?;
2009 } else {
2010 serialize_struct.skip_field("mainEntityOfPage")?;
2011 }
2012 if !Vec::is_empty(&self.r#name) {
2013 serialize_struct.serialize_field("name", {
2014 struct SerializeWith<'a>(&'a Vec<NameProperty>);
2015 impl<'a> Serialize for SerializeWith<'a> {
2016 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2017 where
2018 S: Serializer,
2019 {
2020 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2021 self.0, serializer,
2022 )
2023 }
2024 }
2025 &SerializeWith(&self.r#name)
2026 })?;
2027 } else {
2028 serialize_struct.skip_field("name")?;
2029 }
2030 if !Vec::is_empty(&self.r#potential_action) {
2031 serialize_struct.serialize_field("potentialAction", {
2032 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
2033 impl<'a> Serialize for SerializeWith<'a> {
2034 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2035 where
2036 S: Serializer,
2037 {
2038 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2039 self.0, serializer,
2040 )
2041 }
2042 }
2043 &SerializeWith(&self.r#potential_action)
2044 })?;
2045 } else {
2046 serialize_struct.skip_field("potentialAction")?;
2047 }
2048 if !Vec::is_empty(&self.r#same_as) {
2049 serialize_struct.serialize_field("sameAs", {
2050 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
2051 impl<'a> Serialize for SerializeWith<'a> {
2052 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2053 where
2054 S: Serializer,
2055 {
2056 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2057 self.0, serializer,
2058 )
2059 }
2060 }
2061 &SerializeWith(&self.r#same_as)
2062 })?;
2063 } else {
2064 serialize_struct.skip_field("sameAs")?;
2065 }
2066 if !Vec::is_empty(&self.r#subject_of) {
2067 serialize_struct.serialize_field("subjectOf", {
2068 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
2069 impl<'a> Serialize for SerializeWith<'a> {
2070 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2071 where
2072 S: Serializer,
2073 {
2074 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2075 self.0, serializer,
2076 )
2077 }
2078 }
2079 &SerializeWith(&self.r#subject_of)
2080 })?;
2081 } else {
2082 serialize_struct.skip_field("subjectOf")?;
2083 }
2084 if !Vec::is_empty(&self.r#url) {
2085 serialize_struct.serialize_field("url", {
2086 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
2087 impl<'a> Serialize for SerializeWith<'a> {
2088 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2089 where
2090 S: Serializer,
2091 {
2092 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2093 self.0, serializer,
2094 )
2095 }
2096 }
2097 &SerializeWith(&self.r#url)
2098 })?;
2099 } else {
2100 serialize_struct.skip_field("url")?;
2101 }
2102 serialize_struct.end()
2103 }
2104 }
2105 impl<'de> Deserialize<'de> for Product {
2106 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2107 where
2108 D: Deserializer<'de>,
2109 {
2110 enum Field {
2111 AdditionalProperty,
2112 AggregateRating,
2113 Asin,
2114 Audience,
2115 Award,
2116 Awards,
2117 Brand,
2118 Category,
2119 Color,
2120 CountryOfAssembly,
2121 CountryOfLastProcessing,
2122 CountryOfOrigin,
2123 Depth,
2124 Funding,
2125 Gtin,
2126 Gtin12,
2127 Gtin13,
2128 Gtin14,
2129 Gtin8,
2130 HasAdultConsideration,
2131 HasEnergyConsumptionDetails,
2132 HasMeasurement,
2133 HasMerchantReturnPolicy,
2134 HasProductReturnPolicy,
2135 Height,
2136 InProductGroupWithId,
2137 IsAccessoryOrSparePartFor,
2138 IsConsumableFor,
2139 IsFamilyFriendly,
2140 IsRelatedTo,
2141 IsSimilarTo,
2142 IsVariantOf,
2143 ItemCondition,
2144 Keywords,
2145 Logo,
2146 Manufacturer,
2147 Material,
2148 MobileUrl,
2149 Model,
2150 Mpn,
2151 NegativeNotes,
2152 Nsn,
2153 Offers,
2154 Pattern,
2155 PositiveNotes,
2156 ProductId,
2157 ProductionDate,
2158 PurchaseDate,
2159 ReleaseDate,
2160 Review,
2161 Reviews,
2162 Size,
2163 Sku,
2164 Slogan,
2165 Weight,
2166 Width,
2167 AdditionalType,
2168 AlternateName,
2169 Description,
2170 DisambiguatingDescription,
2171 Identifier,
2172 Image,
2173 MainEntityOfPage,
2174 Name,
2175 PotentialAction,
2176 SameAs,
2177 SubjectOf,
2178 Url,
2179 Ignore,
2180 }
2181 struct FieldVisitor;
2182 impl<'de> Visitor<'de> for FieldVisitor {
2183 type Value = Field;
2184 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
2185 formatter.write_str("field identifier")
2186 }
2187 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2188 where
2189 E: de::Error,
2190 {
2191 match value {
2192 "additionalProperty" => Ok(Field::AdditionalProperty),
2193 "aggregateRating" => Ok(Field::AggregateRating),
2194 "asin" => Ok(Field::Asin),
2195 "audience" => Ok(Field::Audience),
2196 "award" => Ok(Field::Award),
2197 "awards" => Ok(Field::Awards),
2198 "brand" => Ok(Field::Brand),
2199 "category" => Ok(Field::Category),
2200 "color" => Ok(Field::Color),
2201 "countryOfAssembly" => Ok(Field::CountryOfAssembly),
2202 "countryOfLastProcessing" => Ok(Field::CountryOfLastProcessing),
2203 "countryOfOrigin" => Ok(Field::CountryOfOrigin),
2204 "depth" => Ok(Field::Depth),
2205 "funding" => Ok(Field::Funding),
2206 "gtin" => Ok(Field::Gtin),
2207 "gtin12" => Ok(Field::Gtin12),
2208 "gtin13" => Ok(Field::Gtin13),
2209 "gtin14" => Ok(Field::Gtin14),
2210 "gtin8" => Ok(Field::Gtin8),
2211 "hasAdultConsideration" => Ok(Field::HasAdultConsideration),
2212 "hasEnergyConsumptionDetails" => Ok(Field::HasEnergyConsumptionDetails),
2213 "hasMeasurement" => Ok(Field::HasMeasurement),
2214 "hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
2215 "hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
2216 "height" => Ok(Field::Height),
2217 "inProductGroupWithID" => Ok(Field::InProductGroupWithId),
2218 "isAccessoryOrSparePartFor" => Ok(Field::IsAccessoryOrSparePartFor),
2219 "isConsumableFor" => Ok(Field::IsConsumableFor),
2220 "isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
2221 "isRelatedTo" => Ok(Field::IsRelatedTo),
2222 "isSimilarTo" => Ok(Field::IsSimilarTo),
2223 "isVariantOf" => Ok(Field::IsVariantOf),
2224 "itemCondition" => Ok(Field::ItemCondition),
2225 "keywords" => Ok(Field::Keywords),
2226 "logo" => Ok(Field::Logo),
2227 "manufacturer" => Ok(Field::Manufacturer),
2228 "material" => Ok(Field::Material),
2229 "mobileUrl" => Ok(Field::MobileUrl),
2230 "model" => Ok(Field::Model),
2231 "mpn" => Ok(Field::Mpn),
2232 "negativeNotes" => Ok(Field::NegativeNotes),
2233 "nsn" => Ok(Field::Nsn),
2234 "offers" => Ok(Field::Offers),
2235 "pattern" => Ok(Field::Pattern),
2236 "positiveNotes" => Ok(Field::PositiveNotes),
2237 "productID" => Ok(Field::ProductId),
2238 "productionDate" => Ok(Field::ProductionDate),
2239 "purchaseDate" => Ok(Field::PurchaseDate),
2240 "releaseDate" => Ok(Field::ReleaseDate),
2241 "review" => Ok(Field::Review),
2242 "reviews" => Ok(Field::Reviews),
2243 "size" => Ok(Field::Size),
2244 "sku" => Ok(Field::Sku),
2245 "slogan" => Ok(Field::Slogan),
2246 "weight" => Ok(Field::Weight),
2247 "width" => Ok(Field::Width),
2248 "additionalType" => Ok(Field::AdditionalType),
2249 "alternateName" => Ok(Field::AlternateName),
2250 "description" => Ok(Field::Description),
2251 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
2252 "identifier" => Ok(Field::Identifier),
2253 "image" => Ok(Field::Image),
2254 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
2255 "name" => Ok(Field::Name),
2256 "potentialAction" => Ok(Field::PotentialAction),
2257 "sameAs" => Ok(Field::SameAs),
2258 "subjectOf" => Ok(Field::SubjectOf),
2259 "url" => Ok(Field::Url),
2260 "id" | "type" => Ok(Field::Ignore),
2261 _ => Err(de::Error::unknown_field(value, FIELDS)),
2262 }
2263 }
2264 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2265 where
2266 E: de::Error,
2267 {
2268 match value {
2269 b"additionalProperty" => Ok(Field::AdditionalProperty),
2270 b"aggregateRating" => Ok(Field::AggregateRating),
2271 b"asin" => Ok(Field::Asin),
2272 b"audience" => Ok(Field::Audience),
2273 b"award" => Ok(Field::Award),
2274 b"awards" => Ok(Field::Awards),
2275 b"brand" => Ok(Field::Brand),
2276 b"category" => Ok(Field::Category),
2277 b"color" => Ok(Field::Color),
2278 b"countryOfAssembly" => Ok(Field::CountryOfAssembly),
2279 b"countryOfLastProcessing" => Ok(Field::CountryOfLastProcessing),
2280 b"countryOfOrigin" => Ok(Field::CountryOfOrigin),
2281 b"depth" => Ok(Field::Depth),
2282 b"funding" => Ok(Field::Funding),
2283 b"gtin" => Ok(Field::Gtin),
2284 b"gtin12" => Ok(Field::Gtin12),
2285 b"gtin13" => Ok(Field::Gtin13),
2286 b"gtin14" => Ok(Field::Gtin14),
2287 b"gtin8" => Ok(Field::Gtin8),
2288 b"hasAdultConsideration" => Ok(Field::HasAdultConsideration),
2289 b"hasEnergyConsumptionDetails" => Ok(Field::HasEnergyConsumptionDetails),
2290 b"hasMeasurement" => Ok(Field::HasMeasurement),
2291 b"hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
2292 b"hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
2293 b"height" => Ok(Field::Height),
2294 b"inProductGroupWithID" => Ok(Field::InProductGroupWithId),
2295 b"isAccessoryOrSparePartFor" => Ok(Field::IsAccessoryOrSparePartFor),
2296 b"isConsumableFor" => Ok(Field::IsConsumableFor),
2297 b"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
2298 b"isRelatedTo" => Ok(Field::IsRelatedTo),
2299 b"isSimilarTo" => Ok(Field::IsSimilarTo),
2300 b"isVariantOf" => Ok(Field::IsVariantOf),
2301 b"itemCondition" => Ok(Field::ItemCondition),
2302 b"keywords" => Ok(Field::Keywords),
2303 b"logo" => Ok(Field::Logo),
2304 b"manufacturer" => Ok(Field::Manufacturer),
2305 b"material" => Ok(Field::Material),
2306 b"mobileUrl" => Ok(Field::MobileUrl),
2307 b"model" => Ok(Field::Model),
2308 b"mpn" => Ok(Field::Mpn),
2309 b"negativeNotes" => Ok(Field::NegativeNotes),
2310 b"nsn" => Ok(Field::Nsn),
2311 b"offers" => Ok(Field::Offers),
2312 b"pattern" => Ok(Field::Pattern),
2313 b"positiveNotes" => Ok(Field::PositiveNotes),
2314 b"productID" => Ok(Field::ProductId),
2315 b"productionDate" => Ok(Field::ProductionDate),
2316 b"purchaseDate" => Ok(Field::PurchaseDate),
2317 b"releaseDate" => Ok(Field::ReleaseDate),
2318 b"review" => Ok(Field::Review),
2319 b"reviews" => Ok(Field::Reviews),
2320 b"size" => Ok(Field::Size),
2321 b"sku" => Ok(Field::Sku),
2322 b"slogan" => Ok(Field::Slogan),
2323 b"weight" => Ok(Field::Weight),
2324 b"width" => Ok(Field::Width),
2325 b"additionalType" => Ok(Field::AdditionalType),
2326 b"alternateName" => Ok(Field::AlternateName),
2327 b"description" => Ok(Field::Description),
2328 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
2329 b"identifier" => Ok(Field::Identifier),
2330 b"image" => Ok(Field::Image),
2331 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
2332 b"name" => Ok(Field::Name),
2333 b"potentialAction" => Ok(Field::PotentialAction),
2334 b"sameAs" => Ok(Field::SameAs),
2335 b"subjectOf" => Ok(Field::SubjectOf),
2336 b"url" => Ok(Field::Url),
2337 b"id" | b"type" => Ok(Field::Ignore),
2338 _ => {
2339 let value = &String::from_utf8_lossy(value);
2340 Err(de::Error::unknown_field(value, FIELDS))
2341 }
2342 }
2343 }
2344 }
2345 impl<'de> Deserialize<'de> for Field {
2346 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2347 where
2348 D: Deserializer<'de>,
2349 {
2350 deserializer.deserialize_identifier(FieldVisitor)
2351 }
2352 }
2353 struct ClassVisitor;
2354 impl<'de> Visitor<'de> for ClassVisitor {
2355 type Value = Product;
2356 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
2357 formatter.write_str("schema.org schema Product")
2358 }
2359 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2360 where
2361 A: de::MapAccess<'de>,
2362 {
2363 let mut r#additional_property_property = None;
2364 let mut r#aggregate_rating_property = None;
2365 let mut r#asin_property = None;
2366 let mut r#audience_property = None;
2367 let mut r#award_property = None;
2368 let mut r#awards_property = None;
2369 let mut r#brand_property = None;
2370 let mut r#category_property = None;
2371 let mut r#color_property = None;
2372 let mut r#country_of_assembly_property = None;
2373 let mut r#country_of_last_processing_property = None;
2374 let mut r#country_of_origin_property = None;
2375 let mut r#depth_property = None;
2376 let mut r#funding_property = None;
2377 let mut r#gtin_property = None;
2378 let mut r#gtin_12_property = None;
2379 let mut r#gtin_13_property = None;
2380 let mut r#gtin_14_property = None;
2381 let mut r#gtin_8_property = None;
2382 let mut r#has_adult_consideration_property = None;
2383 let mut r#has_energy_consumption_details_property = None;
2384 let mut r#has_measurement_property = None;
2385 let mut r#has_merchant_return_policy_property = None;
2386 let mut r#has_product_return_policy_property = None;
2387 let mut r#height_property = None;
2388 let mut r#in_product_group_with_id_property = None;
2389 let mut r#is_accessory_or_spare_part_for_property = None;
2390 let mut r#is_consumable_for_property = None;
2391 let mut r#is_family_friendly_property = None;
2392 let mut r#is_related_to_property = None;
2393 let mut r#is_similar_to_property = None;
2394 let mut r#is_variant_of_property = None;
2395 let mut r#item_condition_property = None;
2396 let mut r#keywords_property = None;
2397 let mut r#logo_property = None;
2398 let mut r#manufacturer_property = None;
2399 let mut r#material_property = None;
2400 let mut r#mobile_url_property = None;
2401 let mut r#model_property = None;
2402 let mut r#mpn_property = None;
2403 let mut r#negative_notes_property = None;
2404 let mut r#nsn_property = None;
2405 let mut r#offers_property = None;
2406 let mut r#pattern_property = None;
2407 let mut r#positive_notes_property = None;
2408 let mut r#product_id_property = None;
2409 let mut r#production_date_property = None;
2410 let mut r#purchase_date_property = None;
2411 let mut r#release_date_property = None;
2412 let mut r#review_property = None;
2413 let mut r#reviews_property = None;
2414 let mut r#size_property = None;
2415 let mut r#sku_property = None;
2416 let mut r#slogan_property = None;
2417 let mut r#weight_property = None;
2418 let mut r#width_property = None;
2419 let mut r#additional_type_property = None;
2420 let mut r#alternate_name_property = None;
2421 let mut r#description_property = None;
2422 let mut r#disambiguating_description_property = None;
2423 let mut r#identifier_property = None;
2424 let mut r#image_property = None;
2425 let mut r#main_entity_of_page_property = None;
2426 let mut r#name_property = None;
2427 let mut r#potential_action_property = None;
2428 let mut r#same_as_property = None;
2429 let mut r#subject_of_property = None;
2430 let mut r#url_property = None;
2431 while let Some(key) = map.next_key::<Field>()? {
2432 match key {
2433 Field::AdditionalProperty => {
2434 if r#additional_property_property.is_some() {
2435 return Err(<A::Error as de::Error>::duplicate_field(
2436 "additionalProperty",
2437 ));
2438 }
2439 r#additional_property_property = Some({
2440 struct DeserializeWith(Vec<AdditionalPropertyProperty>);
2441 impl<'de> Deserialize<'de> for DeserializeWith {
2442 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2443 where
2444 D: Deserializer<'de>,
2445 {
2446 Ok(DeserializeWith(serde_with::As::<
2447 serde_with::OneOrMany<serde_with::Same>,
2448 >::deserialize(deserializer)?))
2449 }
2450 }
2451 match map.next_value::<DeserializeWith>() {
2452 Ok(deserialize_with) => deserialize_with.0,
2453 Err(err) => {
2454 return Err(err);
2455 }
2456 }
2457 });
2458 }
2459 Field::AggregateRating => {
2460 if r#aggregate_rating_property.is_some() {
2461 return Err(<A::Error as de::Error>::duplicate_field(
2462 "aggregateRating",
2463 ));
2464 }
2465 r#aggregate_rating_property = Some({
2466 struct DeserializeWith(Vec<AggregateRatingProperty>);
2467 impl<'de> Deserialize<'de> for DeserializeWith {
2468 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2469 where
2470 D: Deserializer<'de>,
2471 {
2472 Ok(DeserializeWith(serde_with::As::<
2473 serde_with::OneOrMany<serde_with::Same>,
2474 >::deserialize(deserializer)?))
2475 }
2476 }
2477 match map.next_value::<DeserializeWith>() {
2478 Ok(deserialize_with) => deserialize_with.0,
2479 Err(err) => {
2480 return Err(err);
2481 }
2482 }
2483 });
2484 }
2485 Field::Asin => {
2486 if r#asin_property.is_some() {
2487 return Err(<A::Error as de::Error>::duplicate_field("asin"));
2488 }
2489 r#asin_property = Some({
2490 struct DeserializeWith(Vec<AsinProperty>);
2491 impl<'de> Deserialize<'de> for DeserializeWith {
2492 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2493 where
2494 D: Deserializer<'de>,
2495 {
2496 Ok(DeserializeWith(serde_with::As::<
2497 serde_with::OneOrMany<serde_with::Same>,
2498 >::deserialize(deserializer)?))
2499 }
2500 }
2501 match map.next_value::<DeserializeWith>() {
2502 Ok(deserialize_with) => deserialize_with.0,
2503 Err(err) => {
2504 return Err(err);
2505 }
2506 }
2507 });
2508 }
2509 Field::Audience => {
2510 if r#audience_property.is_some() {
2511 return Err(<A::Error as de::Error>::duplicate_field(
2512 "audience",
2513 ));
2514 }
2515 r#audience_property = Some({
2516 struct DeserializeWith(Vec<AudienceProperty>);
2517 impl<'de> Deserialize<'de> for DeserializeWith {
2518 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2519 where
2520 D: Deserializer<'de>,
2521 {
2522 Ok(DeserializeWith(serde_with::As::<
2523 serde_with::OneOrMany<serde_with::Same>,
2524 >::deserialize(deserializer)?))
2525 }
2526 }
2527 match map.next_value::<DeserializeWith>() {
2528 Ok(deserialize_with) => deserialize_with.0,
2529 Err(err) => {
2530 return Err(err);
2531 }
2532 }
2533 });
2534 }
2535 Field::Award => {
2536 if r#award_property.is_some() {
2537 return Err(<A::Error as de::Error>::duplicate_field("award"));
2538 }
2539 r#award_property = Some({
2540 struct DeserializeWith(Vec<AwardProperty>);
2541 impl<'de> Deserialize<'de> for DeserializeWith {
2542 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2543 where
2544 D: Deserializer<'de>,
2545 {
2546 Ok(DeserializeWith(serde_with::As::<
2547 serde_with::OneOrMany<serde_with::Same>,
2548 >::deserialize(deserializer)?))
2549 }
2550 }
2551 match map.next_value::<DeserializeWith>() {
2552 Ok(deserialize_with) => deserialize_with.0,
2553 Err(err) => {
2554 return Err(err);
2555 }
2556 }
2557 });
2558 }
2559 Field::Awards => {
2560 if r#awards_property.is_some() {
2561 return Err(<A::Error as de::Error>::duplicate_field("awards"));
2562 }
2563 r#awards_property = Some({
2564 struct DeserializeWith(Vec<AwardsProperty>);
2565 impl<'de> Deserialize<'de> for DeserializeWith {
2566 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2567 where
2568 D: Deserializer<'de>,
2569 {
2570 Ok(DeserializeWith(serde_with::As::<
2571 serde_with::OneOrMany<serde_with::Same>,
2572 >::deserialize(deserializer)?))
2573 }
2574 }
2575 match map.next_value::<DeserializeWith>() {
2576 Ok(deserialize_with) => deserialize_with.0,
2577 Err(err) => {
2578 return Err(err);
2579 }
2580 }
2581 });
2582 }
2583 Field::Brand => {
2584 if r#brand_property.is_some() {
2585 return Err(<A::Error as de::Error>::duplicate_field("brand"));
2586 }
2587 r#brand_property = Some({
2588 struct DeserializeWith(Vec<BrandProperty>);
2589 impl<'de> Deserialize<'de> for DeserializeWith {
2590 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2591 where
2592 D: Deserializer<'de>,
2593 {
2594 Ok(DeserializeWith(serde_with::As::<
2595 serde_with::OneOrMany<serde_with::Same>,
2596 >::deserialize(deserializer)?))
2597 }
2598 }
2599 match map.next_value::<DeserializeWith>() {
2600 Ok(deserialize_with) => deserialize_with.0,
2601 Err(err) => {
2602 return Err(err);
2603 }
2604 }
2605 });
2606 }
2607 Field::Category => {
2608 if r#category_property.is_some() {
2609 return Err(<A::Error as de::Error>::duplicate_field(
2610 "category",
2611 ));
2612 }
2613 r#category_property = Some({
2614 struct DeserializeWith(Vec<CategoryProperty>);
2615 impl<'de> Deserialize<'de> for DeserializeWith {
2616 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2617 where
2618 D: Deserializer<'de>,
2619 {
2620 Ok(DeserializeWith(serde_with::As::<
2621 serde_with::OneOrMany<serde_with::Same>,
2622 >::deserialize(deserializer)?))
2623 }
2624 }
2625 match map.next_value::<DeserializeWith>() {
2626 Ok(deserialize_with) => deserialize_with.0,
2627 Err(err) => {
2628 return Err(err);
2629 }
2630 }
2631 });
2632 }
2633 Field::Color => {
2634 if r#color_property.is_some() {
2635 return Err(<A::Error as de::Error>::duplicate_field("color"));
2636 }
2637 r#color_property = Some({
2638 struct DeserializeWith(Vec<ColorProperty>);
2639 impl<'de> Deserialize<'de> for DeserializeWith {
2640 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2641 where
2642 D: Deserializer<'de>,
2643 {
2644 Ok(DeserializeWith(serde_with::As::<
2645 serde_with::OneOrMany<serde_with::Same>,
2646 >::deserialize(deserializer)?))
2647 }
2648 }
2649 match map.next_value::<DeserializeWith>() {
2650 Ok(deserialize_with) => deserialize_with.0,
2651 Err(err) => {
2652 return Err(err);
2653 }
2654 }
2655 });
2656 }
2657 Field::CountryOfAssembly => {
2658 if r#country_of_assembly_property.is_some() {
2659 return Err(<A::Error as de::Error>::duplicate_field(
2660 "countryOfAssembly",
2661 ));
2662 }
2663 r#country_of_assembly_property = Some({
2664 struct DeserializeWith(Vec<CountryOfAssemblyProperty>);
2665 impl<'de> Deserialize<'de> for DeserializeWith {
2666 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2667 where
2668 D: Deserializer<'de>,
2669 {
2670 Ok(DeserializeWith(serde_with::As::<
2671 serde_with::OneOrMany<serde_with::Same>,
2672 >::deserialize(deserializer)?))
2673 }
2674 }
2675 match map.next_value::<DeserializeWith>() {
2676 Ok(deserialize_with) => deserialize_with.0,
2677 Err(err) => {
2678 return Err(err);
2679 }
2680 }
2681 });
2682 }
2683 Field::CountryOfLastProcessing => {
2684 if r#country_of_last_processing_property.is_some() {
2685 return Err(<A::Error as de::Error>::duplicate_field(
2686 "countryOfLastProcessing",
2687 ));
2688 }
2689 r#country_of_last_processing_property = Some({
2690 struct DeserializeWith(Vec<CountryOfLastProcessingProperty>);
2691 impl<'de> Deserialize<'de> for DeserializeWith {
2692 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2693 where
2694 D: Deserializer<'de>,
2695 {
2696 Ok(DeserializeWith(serde_with::As::<
2697 serde_with::OneOrMany<serde_with::Same>,
2698 >::deserialize(deserializer)?))
2699 }
2700 }
2701 match map.next_value::<DeserializeWith>() {
2702 Ok(deserialize_with) => deserialize_with.0,
2703 Err(err) => {
2704 return Err(err);
2705 }
2706 }
2707 });
2708 }
2709 Field::CountryOfOrigin => {
2710 if r#country_of_origin_property.is_some() {
2711 return Err(<A::Error as de::Error>::duplicate_field(
2712 "countryOfOrigin",
2713 ));
2714 }
2715 r#country_of_origin_property = Some({
2716 struct DeserializeWith(Vec<CountryOfOriginProperty>);
2717 impl<'de> Deserialize<'de> for DeserializeWith {
2718 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2719 where
2720 D: Deserializer<'de>,
2721 {
2722 Ok(DeserializeWith(serde_with::As::<
2723 serde_with::OneOrMany<serde_with::Same>,
2724 >::deserialize(deserializer)?))
2725 }
2726 }
2727 match map.next_value::<DeserializeWith>() {
2728 Ok(deserialize_with) => deserialize_with.0,
2729 Err(err) => {
2730 return Err(err);
2731 }
2732 }
2733 });
2734 }
2735 Field::Depth => {
2736 if r#depth_property.is_some() {
2737 return Err(<A::Error as de::Error>::duplicate_field("depth"));
2738 }
2739 r#depth_property = Some({
2740 struct DeserializeWith(Vec<DepthProperty>);
2741 impl<'de> Deserialize<'de> for DeserializeWith {
2742 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2743 where
2744 D: Deserializer<'de>,
2745 {
2746 Ok(DeserializeWith(serde_with::As::<
2747 serde_with::OneOrMany<serde_with::Same>,
2748 >::deserialize(deserializer)?))
2749 }
2750 }
2751 match map.next_value::<DeserializeWith>() {
2752 Ok(deserialize_with) => deserialize_with.0,
2753 Err(err) => {
2754 return Err(err);
2755 }
2756 }
2757 });
2758 }
2759 Field::Funding => {
2760 if r#funding_property.is_some() {
2761 return Err(<A::Error as de::Error>::duplicate_field(
2762 "funding",
2763 ));
2764 }
2765 r#funding_property = Some({
2766 struct DeserializeWith(Vec<FundingProperty>);
2767 impl<'de> Deserialize<'de> for DeserializeWith {
2768 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2769 where
2770 D: Deserializer<'de>,
2771 {
2772 Ok(DeserializeWith(serde_with::As::<
2773 serde_with::OneOrMany<serde_with::Same>,
2774 >::deserialize(deserializer)?))
2775 }
2776 }
2777 match map.next_value::<DeserializeWith>() {
2778 Ok(deserialize_with) => deserialize_with.0,
2779 Err(err) => {
2780 return Err(err);
2781 }
2782 }
2783 });
2784 }
2785 Field::Gtin => {
2786 if r#gtin_property.is_some() {
2787 return Err(<A::Error as de::Error>::duplicate_field("gtin"));
2788 }
2789 r#gtin_property = Some({
2790 struct DeserializeWith(Vec<GtinProperty>);
2791 impl<'de> Deserialize<'de> for DeserializeWith {
2792 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2793 where
2794 D: Deserializer<'de>,
2795 {
2796 Ok(DeserializeWith(serde_with::As::<
2797 serde_with::OneOrMany<serde_with::Same>,
2798 >::deserialize(deserializer)?))
2799 }
2800 }
2801 match map.next_value::<DeserializeWith>() {
2802 Ok(deserialize_with) => deserialize_with.0,
2803 Err(err) => {
2804 return Err(err);
2805 }
2806 }
2807 });
2808 }
2809 Field::Gtin12 => {
2810 if r#gtin_12_property.is_some() {
2811 return Err(<A::Error as de::Error>::duplicate_field("gtin12"));
2812 }
2813 r#gtin_12_property = Some({
2814 struct DeserializeWith(Vec<Gtin12Property>);
2815 impl<'de> Deserialize<'de> for DeserializeWith {
2816 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2817 where
2818 D: Deserializer<'de>,
2819 {
2820 Ok(DeserializeWith(serde_with::As::<
2821 serde_with::OneOrMany<serde_with::Same>,
2822 >::deserialize(deserializer)?))
2823 }
2824 }
2825 match map.next_value::<DeserializeWith>() {
2826 Ok(deserialize_with) => deserialize_with.0,
2827 Err(err) => {
2828 return Err(err);
2829 }
2830 }
2831 });
2832 }
2833 Field::Gtin13 => {
2834 if r#gtin_13_property.is_some() {
2835 return Err(<A::Error as de::Error>::duplicate_field("gtin13"));
2836 }
2837 r#gtin_13_property = Some({
2838 struct DeserializeWith(Vec<Gtin13Property>);
2839 impl<'de> Deserialize<'de> for DeserializeWith {
2840 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2841 where
2842 D: Deserializer<'de>,
2843 {
2844 Ok(DeserializeWith(serde_with::As::<
2845 serde_with::OneOrMany<serde_with::Same>,
2846 >::deserialize(deserializer)?))
2847 }
2848 }
2849 match map.next_value::<DeserializeWith>() {
2850 Ok(deserialize_with) => deserialize_with.0,
2851 Err(err) => {
2852 return Err(err);
2853 }
2854 }
2855 });
2856 }
2857 Field::Gtin14 => {
2858 if r#gtin_14_property.is_some() {
2859 return Err(<A::Error as de::Error>::duplicate_field("gtin14"));
2860 }
2861 r#gtin_14_property = Some({
2862 struct DeserializeWith(Vec<Gtin14Property>);
2863 impl<'de> Deserialize<'de> for DeserializeWith {
2864 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2865 where
2866 D: Deserializer<'de>,
2867 {
2868 Ok(DeserializeWith(serde_with::As::<
2869 serde_with::OneOrMany<serde_with::Same>,
2870 >::deserialize(deserializer)?))
2871 }
2872 }
2873 match map.next_value::<DeserializeWith>() {
2874 Ok(deserialize_with) => deserialize_with.0,
2875 Err(err) => {
2876 return Err(err);
2877 }
2878 }
2879 });
2880 }
2881 Field::Gtin8 => {
2882 if r#gtin_8_property.is_some() {
2883 return Err(<A::Error as de::Error>::duplicate_field("gtin8"));
2884 }
2885 r#gtin_8_property = Some({
2886 struct DeserializeWith(Vec<Gtin8Property>);
2887 impl<'de> Deserialize<'de> for DeserializeWith {
2888 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2889 where
2890 D: Deserializer<'de>,
2891 {
2892 Ok(DeserializeWith(serde_with::As::<
2893 serde_with::OneOrMany<serde_with::Same>,
2894 >::deserialize(deserializer)?))
2895 }
2896 }
2897 match map.next_value::<DeserializeWith>() {
2898 Ok(deserialize_with) => deserialize_with.0,
2899 Err(err) => {
2900 return Err(err);
2901 }
2902 }
2903 });
2904 }
2905 Field::HasAdultConsideration => {
2906 if r#has_adult_consideration_property.is_some() {
2907 return Err(<A::Error as de::Error>::duplicate_field(
2908 "hasAdultConsideration",
2909 ));
2910 }
2911 r#has_adult_consideration_property = Some({
2912 struct DeserializeWith(Vec<HasAdultConsiderationProperty>);
2913 impl<'de> Deserialize<'de> for DeserializeWith {
2914 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2915 where
2916 D: Deserializer<'de>,
2917 {
2918 Ok(DeserializeWith(serde_with::As::<
2919 serde_with::OneOrMany<serde_with::Same>,
2920 >::deserialize(deserializer)?))
2921 }
2922 }
2923 match map.next_value::<DeserializeWith>() {
2924 Ok(deserialize_with) => deserialize_with.0,
2925 Err(err) => {
2926 return Err(err);
2927 }
2928 }
2929 });
2930 }
2931 Field::HasEnergyConsumptionDetails => {
2932 if r#has_energy_consumption_details_property.is_some() {
2933 return Err(<A::Error as de::Error>::duplicate_field(
2934 "hasEnergyConsumptionDetails",
2935 ));
2936 }
2937 r#has_energy_consumption_details_property = Some({
2938 struct DeserializeWith(
2939 Vec<HasEnergyConsumptionDetailsProperty>,
2940 );
2941 impl<'de> Deserialize<'de> for DeserializeWith {
2942 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2943 where
2944 D: Deserializer<'de>,
2945 {
2946 Ok(DeserializeWith(serde_with::As::<
2947 serde_with::OneOrMany<serde_with::Same>,
2948 >::deserialize(deserializer)?))
2949 }
2950 }
2951 match map.next_value::<DeserializeWith>() {
2952 Ok(deserialize_with) => deserialize_with.0,
2953 Err(err) => {
2954 return Err(err);
2955 }
2956 }
2957 });
2958 }
2959 Field::HasMeasurement => {
2960 if r#has_measurement_property.is_some() {
2961 return Err(<A::Error as de::Error>::duplicate_field(
2962 "hasMeasurement",
2963 ));
2964 }
2965 r#has_measurement_property = Some({
2966 struct DeserializeWith(Vec<HasMeasurementProperty>);
2967 impl<'de> Deserialize<'de> for DeserializeWith {
2968 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2969 where
2970 D: Deserializer<'de>,
2971 {
2972 Ok(DeserializeWith(serde_with::As::<
2973 serde_with::OneOrMany<serde_with::Same>,
2974 >::deserialize(deserializer)?))
2975 }
2976 }
2977 match map.next_value::<DeserializeWith>() {
2978 Ok(deserialize_with) => deserialize_with.0,
2979 Err(err) => {
2980 return Err(err);
2981 }
2982 }
2983 });
2984 }
2985 Field::HasMerchantReturnPolicy => {
2986 if r#has_merchant_return_policy_property.is_some() {
2987 return Err(<A::Error as de::Error>::duplicate_field(
2988 "hasMerchantReturnPolicy",
2989 ));
2990 }
2991 r#has_merchant_return_policy_property = Some({
2992 struct DeserializeWith(Vec<HasMerchantReturnPolicyProperty>);
2993 impl<'de> Deserialize<'de> for DeserializeWith {
2994 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2995 where
2996 D: Deserializer<'de>,
2997 {
2998 Ok(DeserializeWith(serde_with::As::<
2999 serde_with::OneOrMany<serde_with::Same>,
3000 >::deserialize(deserializer)?))
3001 }
3002 }
3003 match map.next_value::<DeserializeWith>() {
3004 Ok(deserialize_with) => deserialize_with.0,
3005 Err(err) => {
3006 return Err(err);
3007 }
3008 }
3009 });
3010 }
3011 Field::HasProductReturnPolicy => {
3012 if r#has_product_return_policy_property.is_some() {
3013 return Err(<A::Error as de::Error>::duplicate_field(
3014 "hasProductReturnPolicy",
3015 ));
3016 }
3017 r#has_product_return_policy_property = Some({
3018 struct DeserializeWith(Vec<HasProductReturnPolicyProperty>);
3019 impl<'de> Deserialize<'de> for DeserializeWith {
3020 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3021 where
3022 D: Deserializer<'de>,
3023 {
3024 Ok(DeserializeWith(serde_with::As::<
3025 serde_with::OneOrMany<serde_with::Same>,
3026 >::deserialize(deserializer)?))
3027 }
3028 }
3029 match map.next_value::<DeserializeWith>() {
3030 Ok(deserialize_with) => deserialize_with.0,
3031 Err(err) => {
3032 return Err(err);
3033 }
3034 }
3035 });
3036 }
3037 Field::Height => {
3038 if r#height_property.is_some() {
3039 return Err(<A::Error as de::Error>::duplicate_field("height"));
3040 }
3041 r#height_property = Some({
3042 struct DeserializeWith(Vec<HeightProperty>);
3043 impl<'de> Deserialize<'de> for DeserializeWith {
3044 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3045 where
3046 D: Deserializer<'de>,
3047 {
3048 Ok(DeserializeWith(serde_with::As::<
3049 serde_with::OneOrMany<serde_with::Same>,
3050 >::deserialize(deserializer)?))
3051 }
3052 }
3053 match map.next_value::<DeserializeWith>() {
3054 Ok(deserialize_with) => deserialize_with.0,
3055 Err(err) => {
3056 return Err(err);
3057 }
3058 }
3059 });
3060 }
3061 Field::InProductGroupWithId => {
3062 if r#in_product_group_with_id_property.is_some() {
3063 return Err(<A::Error as de::Error>::duplicate_field(
3064 "inProductGroupWithID",
3065 ));
3066 }
3067 r#in_product_group_with_id_property = Some({
3068 struct DeserializeWith(Vec<InProductGroupWithIdProperty>);
3069 impl<'de> Deserialize<'de> for DeserializeWith {
3070 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3071 where
3072 D: Deserializer<'de>,
3073 {
3074 Ok(DeserializeWith(serde_with::As::<
3075 serde_with::OneOrMany<serde_with::Same>,
3076 >::deserialize(deserializer)?))
3077 }
3078 }
3079 match map.next_value::<DeserializeWith>() {
3080 Ok(deserialize_with) => deserialize_with.0,
3081 Err(err) => {
3082 return Err(err);
3083 }
3084 }
3085 });
3086 }
3087 Field::IsAccessoryOrSparePartFor => {
3088 if r#is_accessory_or_spare_part_for_property.is_some() {
3089 return Err(<A::Error as de::Error>::duplicate_field(
3090 "isAccessoryOrSparePartFor",
3091 ));
3092 }
3093 r#is_accessory_or_spare_part_for_property = Some({
3094 struct DeserializeWith(Vec<IsAccessoryOrSparePartForProperty>);
3095 impl<'de> Deserialize<'de> for DeserializeWith {
3096 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3097 where
3098 D: Deserializer<'de>,
3099 {
3100 Ok(DeserializeWith(serde_with::As::<
3101 serde_with::OneOrMany<serde_with::Same>,
3102 >::deserialize(deserializer)?))
3103 }
3104 }
3105 match map.next_value::<DeserializeWith>() {
3106 Ok(deserialize_with) => deserialize_with.0,
3107 Err(err) => {
3108 return Err(err);
3109 }
3110 }
3111 });
3112 }
3113 Field::IsConsumableFor => {
3114 if r#is_consumable_for_property.is_some() {
3115 return Err(<A::Error as de::Error>::duplicate_field(
3116 "isConsumableFor",
3117 ));
3118 }
3119 r#is_consumable_for_property = Some({
3120 struct DeserializeWith(Vec<IsConsumableForProperty>);
3121 impl<'de> Deserialize<'de> for DeserializeWith {
3122 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3123 where
3124 D: Deserializer<'de>,
3125 {
3126 Ok(DeserializeWith(serde_with::As::<
3127 serde_with::OneOrMany<serde_with::Same>,
3128 >::deserialize(deserializer)?))
3129 }
3130 }
3131 match map.next_value::<DeserializeWith>() {
3132 Ok(deserialize_with) => deserialize_with.0,
3133 Err(err) => {
3134 return Err(err);
3135 }
3136 }
3137 });
3138 }
3139 Field::IsFamilyFriendly => {
3140 if r#is_family_friendly_property.is_some() {
3141 return Err(<A::Error as de::Error>::duplicate_field(
3142 "isFamilyFriendly",
3143 ));
3144 }
3145 r#is_family_friendly_property = Some({
3146 struct DeserializeWith(Vec<IsFamilyFriendlyProperty>);
3147 impl<'de> Deserialize<'de> for DeserializeWith {
3148 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3149 where
3150 D: Deserializer<'de>,
3151 {
3152 Ok(DeserializeWith(serde_with::As::<
3153 serde_with::OneOrMany<serde_with::Same>,
3154 >::deserialize(deserializer)?))
3155 }
3156 }
3157 match map.next_value::<DeserializeWith>() {
3158 Ok(deserialize_with) => deserialize_with.0,
3159 Err(err) => {
3160 return Err(err);
3161 }
3162 }
3163 });
3164 }
3165 Field::IsRelatedTo => {
3166 if r#is_related_to_property.is_some() {
3167 return Err(<A::Error as de::Error>::duplicate_field(
3168 "isRelatedTo",
3169 ));
3170 }
3171 r#is_related_to_property = Some({
3172 struct DeserializeWith(Vec<IsRelatedToProperty>);
3173 impl<'de> Deserialize<'de> for DeserializeWith {
3174 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3175 where
3176 D: Deserializer<'de>,
3177 {
3178 Ok(DeserializeWith(serde_with::As::<
3179 serde_with::OneOrMany<serde_with::Same>,
3180 >::deserialize(deserializer)?))
3181 }
3182 }
3183 match map.next_value::<DeserializeWith>() {
3184 Ok(deserialize_with) => deserialize_with.0,
3185 Err(err) => {
3186 return Err(err);
3187 }
3188 }
3189 });
3190 }
3191 Field::IsSimilarTo => {
3192 if r#is_similar_to_property.is_some() {
3193 return Err(<A::Error as de::Error>::duplicate_field(
3194 "isSimilarTo",
3195 ));
3196 }
3197 r#is_similar_to_property = Some({
3198 struct DeserializeWith(Vec<IsSimilarToProperty>);
3199 impl<'de> Deserialize<'de> for DeserializeWith {
3200 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3201 where
3202 D: Deserializer<'de>,
3203 {
3204 Ok(DeserializeWith(serde_with::As::<
3205 serde_with::OneOrMany<serde_with::Same>,
3206 >::deserialize(deserializer)?))
3207 }
3208 }
3209 match map.next_value::<DeserializeWith>() {
3210 Ok(deserialize_with) => deserialize_with.0,
3211 Err(err) => {
3212 return Err(err);
3213 }
3214 }
3215 });
3216 }
3217 Field::IsVariantOf => {
3218 if r#is_variant_of_property.is_some() {
3219 return Err(<A::Error as de::Error>::duplicate_field(
3220 "isVariantOf",
3221 ));
3222 }
3223 r#is_variant_of_property = Some({
3224 struct DeserializeWith(Vec<IsVariantOfProperty>);
3225 impl<'de> Deserialize<'de> for DeserializeWith {
3226 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3227 where
3228 D: Deserializer<'de>,
3229 {
3230 Ok(DeserializeWith(serde_with::As::<
3231 serde_with::OneOrMany<serde_with::Same>,
3232 >::deserialize(deserializer)?))
3233 }
3234 }
3235 match map.next_value::<DeserializeWith>() {
3236 Ok(deserialize_with) => deserialize_with.0,
3237 Err(err) => {
3238 return Err(err);
3239 }
3240 }
3241 });
3242 }
3243 Field::ItemCondition => {
3244 if r#item_condition_property.is_some() {
3245 return Err(<A::Error as de::Error>::duplicate_field(
3246 "itemCondition",
3247 ));
3248 }
3249 r#item_condition_property = Some({
3250 struct DeserializeWith(Vec<ItemConditionProperty>);
3251 impl<'de> Deserialize<'de> for DeserializeWith {
3252 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3253 where
3254 D: Deserializer<'de>,
3255 {
3256 Ok(DeserializeWith(serde_with::As::<
3257 serde_with::OneOrMany<serde_with::Same>,
3258 >::deserialize(deserializer)?))
3259 }
3260 }
3261 match map.next_value::<DeserializeWith>() {
3262 Ok(deserialize_with) => deserialize_with.0,
3263 Err(err) => {
3264 return Err(err);
3265 }
3266 }
3267 });
3268 }
3269 Field::Keywords => {
3270 if r#keywords_property.is_some() {
3271 return Err(<A::Error as de::Error>::duplicate_field(
3272 "keywords",
3273 ));
3274 }
3275 r#keywords_property = Some({
3276 struct DeserializeWith(Vec<KeywordsProperty>);
3277 impl<'de> Deserialize<'de> for DeserializeWith {
3278 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3279 where
3280 D: Deserializer<'de>,
3281 {
3282 Ok(DeserializeWith(serde_with::As::<
3283 serde_with::OneOrMany<serde_with::Same>,
3284 >::deserialize(deserializer)?))
3285 }
3286 }
3287 match map.next_value::<DeserializeWith>() {
3288 Ok(deserialize_with) => deserialize_with.0,
3289 Err(err) => {
3290 return Err(err);
3291 }
3292 }
3293 });
3294 }
3295 Field::Logo => {
3296 if r#logo_property.is_some() {
3297 return Err(<A::Error as de::Error>::duplicate_field("logo"));
3298 }
3299 r#logo_property = Some({
3300 struct DeserializeWith(Vec<LogoProperty>);
3301 impl<'de> Deserialize<'de> for DeserializeWith {
3302 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3303 where
3304 D: Deserializer<'de>,
3305 {
3306 Ok(DeserializeWith(serde_with::As::<
3307 serde_with::OneOrMany<serde_with::Same>,
3308 >::deserialize(deserializer)?))
3309 }
3310 }
3311 match map.next_value::<DeserializeWith>() {
3312 Ok(deserialize_with) => deserialize_with.0,
3313 Err(err) => {
3314 return Err(err);
3315 }
3316 }
3317 });
3318 }
3319 Field::Manufacturer => {
3320 if r#manufacturer_property.is_some() {
3321 return Err(<A::Error as de::Error>::duplicate_field(
3322 "manufacturer",
3323 ));
3324 }
3325 r#manufacturer_property = Some({
3326 struct DeserializeWith(Vec<ManufacturerProperty>);
3327 impl<'de> Deserialize<'de> for DeserializeWith {
3328 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3329 where
3330 D: Deserializer<'de>,
3331 {
3332 Ok(DeserializeWith(serde_with::As::<
3333 serde_with::OneOrMany<serde_with::Same>,
3334 >::deserialize(deserializer)?))
3335 }
3336 }
3337 match map.next_value::<DeserializeWith>() {
3338 Ok(deserialize_with) => deserialize_with.0,
3339 Err(err) => {
3340 return Err(err);
3341 }
3342 }
3343 });
3344 }
3345 Field::Material => {
3346 if r#material_property.is_some() {
3347 return Err(<A::Error as de::Error>::duplicate_field(
3348 "material",
3349 ));
3350 }
3351 r#material_property = Some({
3352 struct DeserializeWith(Vec<MaterialProperty>);
3353 impl<'de> Deserialize<'de> for DeserializeWith {
3354 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3355 where
3356 D: Deserializer<'de>,
3357 {
3358 Ok(DeserializeWith(serde_with::As::<
3359 serde_with::OneOrMany<serde_with::Same>,
3360 >::deserialize(deserializer)?))
3361 }
3362 }
3363 match map.next_value::<DeserializeWith>() {
3364 Ok(deserialize_with) => deserialize_with.0,
3365 Err(err) => {
3366 return Err(err);
3367 }
3368 }
3369 });
3370 }
3371 Field::MobileUrl => {
3372 if r#mobile_url_property.is_some() {
3373 return Err(<A::Error as de::Error>::duplicate_field(
3374 "mobileUrl",
3375 ));
3376 }
3377 r#mobile_url_property = Some({
3378 struct DeserializeWith(Vec<MobileUrlProperty>);
3379 impl<'de> Deserialize<'de> for DeserializeWith {
3380 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3381 where
3382 D: Deserializer<'de>,
3383 {
3384 Ok(DeserializeWith(serde_with::As::<
3385 serde_with::OneOrMany<serde_with::Same>,
3386 >::deserialize(deserializer)?))
3387 }
3388 }
3389 match map.next_value::<DeserializeWith>() {
3390 Ok(deserialize_with) => deserialize_with.0,
3391 Err(err) => {
3392 return Err(err);
3393 }
3394 }
3395 });
3396 }
3397 Field::Model => {
3398 if r#model_property.is_some() {
3399 return Err(<A::Error as de::Error>::duplicate_field("model"));
3400 }
3401 r#model_property = Some({
3402 struct DeserializeWith(Vec<ModelProperty>);
3403 impl<'de> Deserialize<'de> for DeserializeWith {
3404 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3405 where
3406 D: Deserializer<'de>,
3407 {
3408 Ok(DeserializeWith(serde_with::As::<
3409 serde_with::OneOrMany<serde_with::Same>,
3410 >::deserialize(deserializer)?))
3411 }
3412 }
3413 match map.next_value::<DeserializeWith>() {
3414 Ok(deserialize_with) => deserialize_with.0,
3415 Err(err) => {
3416 return Err(err);
3417 }
3418 }
3419 });
3420 }
3421 Field::Mpn => {
3422 if r#mpn_property.is_some() {
3423 return Err(<A::Error as de::Error>::duplicate_field("mpn"));
3424 }
3425 r#mpn_property = Some({
3426 struct DeserializeWith(Vec<MpnProperty>);
3427 impl<'de> Deserialize<'de> for DeserializeWith {
3428 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3429 where
3430 D: Deserializer<'de>,
3431 {
3432 Ok(DeserializeWith(serde_with::As::<
3433 serde_with::OneOrMany<serde_with::Same>,
3434 >::deserialize(deserializer)?))
3435 }
3436 }
3437 match map.next_value::<DeserializeWith>() {
3438 Ok(deserialize_with) => deserialize_with.0,
3439 Err(err) => {
3440 return Err(err);
3441 }
3442 }
3443 });
3444 }
3445 Field::NegativeNotes => {
3446 if r#negative_notes_property.is_some() {
3447 return Err(<A::Error as de::Error>::duplicate_field(
3448 "negativeNotes",
3449 ));
3450 }
3451 r#negative_notes_property = Some({
3452 struct DeserializeWith(Vec<NegativeNotesProperty>);
3453 impl<'de> Deserialize<'de> for DeserializeWith {
3454 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3455 where
3456 D: Deserializer<'de>,
3457 {
3458 Ok(DeserializeWith(serde_with::As::<
3459 serde_with::OneOrMany<serde_with::Same>,
3460 >::deserialize(deserializer)?))
3461 }
3462 }
3463 match map.next_value::<DeserializeWith>() {
3464 Ok(deserialize_with) => deserialize_with.0,
3465 Err(err) => {
3466 return Err(err);
3467 }
3468 }
3469 });
3470 }
3471 Field::Nsn => {
3472 if r#nsn_property.is_some() {
3473 return Err(<A::Error as de::Error>::duplicate_field("nsn"));
3474 }
3475 r#nsn_property = Some({
3476 struct DeserializeWith(Vec<NsnProperty>);
3477 impl<'de> Deserialize<'de> for DeserializeWith {
3478 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3479 where
3480 D: Deserializer<'de>,
3481 {
3482 Ok(DeserializeWith(serde_with::As::<
3483 serde_with::OneOrMany<serde_with::Same>,
3484 >::deserialize(deserializer)?))
3485 }
3486 }
3487 match map.next_value::<DeserializeWith>() {
3488 Ok(deserialize_with) => deserialize_with.0,
3489 Err(err) => {
3490 return Err(err);
3491 }
3492 }
3493 });
3494 }
3495 Field::Offers => {
3496 if r#offers_property.is_some() {
3497 return Err(<A::Error as de::Error>::duplicate_field("offers"));
3498 }
3499 r#offers_property = Some({
3500 struct DeserializeWith(Vec<OffersProperty>);
3501 impl<'de> Deserialize<'de> for DeserializeWith {
3502 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3503 where
3504 D: Deserializer<'de>,
3505 {
3506 Ok(DeserializeWith(serde_with::As::<
3507 serde_with::OneOrMany<serde_with::Same>,
3508 >::deserialize(deserializer)?))
3509 }
3510 }
3511 match map.next_value::<DeserializeWith>() {
3512 Ok(deserialize_with) => deserialize_with.0,
3513 Err(err) => {
3514 return Err(err);
3515 }
3516 }
3517 });
3518 }
3519 Field::Pattern => {
3520 if r#pattern_property.is_some() {
3521 return Err(<A::Error as de::Error>::duplicate_field(
3522 "pattern",
3523 ));
3524 }
3525 r#pattern_property = Some({
3526 struct DeserializeWith(Vec<PatternProperty>);
3527 impl<'de> Deserialize<'de> for DeserializeWith {
3528 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3529 where
3530 D: Deserializer<'de>,
3531 {
3532 Ok(DeserializeWith(serde_with::As::<
3533 serde_with::OneOrMany<serde_with::Same>,
3534 >::deserialize(deserializer)?))
3535 }
3536 }
3537 match map.next_value::<DeserializeWith>() {
3538 Ok(deserialize_with) => deserialize_with.0,
3539 Err(err) => {
3540 return Err(err);
3541 }
3542 }
3543 });
3544 }
3545 Field::PositiveNotes => {
3546 if r#positive_notes_property.is_some() {
3547 return Err(<A::Error as de::Error>::duplicate_field(
3548 "positiveNotes",
3549 ));
3550 }
3551 r#positive_notes_property = Some({
3552 struct DeserializeWith(Vec<PositiveNotesProperty>);
3553 impl<'de> Deserialize<'de> for DeserializeWith {
3554 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3555 where
3556 D: Deserializer<'de>,
3557 {
3558 Ok(DeserializeWith(serde_with::As::<
3559 serde_with::OneOrMany<serde_with::Same>,
3560 >::deserialize(deserializer)?))
3561 }
3562 }
3563 match map.next_value::<DeserializeWith>() {
3564 Ok(deserialize_with) => deserialize_with.0,
3565 Err(err) => {
3566 return Err(err);
3567 }
3568 }
3569 });
3570 }
3571 Field::ProductId => {
3572 if r#product_id_property.is_some() {
3573 return Err(<A::Error as de::Error>::duplicate_field(
3574 "productID",
3575 ));
3576 }
3577 r#product_id_property = Some({
3578 struct DeserializeWith(Vec<ProductIdProperty>);
3579 impl<'de> Deserialize<'de> for DeserializeWith {
3580 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3581 where
3582 D: Deserializer<'de>,
3583 {
3584 Ok(DeserializeWith(serde_with::As::<
3585 serde_with::OneOrMany<serde_with::Same>,
3586 >::deserialize(deserializer)?))
3587 }
3588 }
3589 match map.next_value::<DeserializeWith>() {
3590 Ok(deserialize_with) => deserialize_with.0,
3591 Err(err) => {
3592 return Err(err);
3593 }
3594 }
3595 });
3596 }
3597 Field::ProductionDate => {
3598 if r#production_date_property.is_some() {
3599 return Err(<A::Error as de::Error>::duplicate_field(
3600 "productionDate",
3601 ));
3602 }
3603 r#production_date_property = Some({
3604 struct DeserializeWith(Vec<ProductionDateProperty>);
3605 impl<'de> Deserialize<'de> for DeserializeWith {
3606 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3607 where
3608 D: Deserializer<'de>,
3609 {
3610 Ok(DeserializeWith(serde_with::As::<
3611 serde_with::OneOrMany<serde_with::Same>,
3612 >::deserialize(deserializer)?))
3613 }
3614 }
3615 match map.next_value::<DeserializeWith>() {
3616 Ok(deserialize_with) => deserialize_with.0,
3617 Err(err) => {
3618 return Err(err);
3619 }
3620 }
3621 });
3622 }
3623 Field::PurchaseDate => {
3624 if r#purchase_date_property.is_some() {
3625 return Err(<A::Error as de::Error>::duplicate_field(
3626 "purchaseDate",
3627 ));
3628 }
3629 r#purchase_date_property = Some({
3630 struct DeserializeWith(Vec<PurchaseDateProperty>);
3631 impl<'de> Deserialize<'de> for DeserializeWith {
3632 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3633 where
3634 D: Deserializer<'de>,
3635 {
3636 Ok(DeserializeWith(serde_with::As::<
3637 serde_with::OneOrMany<serde_with::Same>,
3638 >::deserialize(deserializer)?))
3639 }
3640 }
3641 match map.next_value::<DeserializeWith>() {
3642 Ok(deserialize_with) => deserialize_with.0,
3643 Err(err) => {
3644 return Err(err);
3645 }
3646 }
3647 });
3648 }
3649 Field::ReleaseDate => {
3650 if r#release_date_property.is_some() {
3651 return Err(<A::Error as de::Error>::duplicate_field(
3652 "releaseDate",
3653 ));
3654 }
3655 r#release_date_property = Some({
3656 struct DeserializeWith(Vec<ReleaseDateProperty>);
3657 impl<'de> Deserialize<'de> for DeserializeWith {
3658 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3659 where
3660 D: Deserializer<'de>,
3661 {
3662 Ok(DeserializeWith(serde_with::As::<
3663 serde_with::OneOrMany<serde_with::Same>,
3664 >::deserialize(deserializer)?))
3665 }
3666 }
3667 match map.next_value::<DeserializeWith>() {
3668 Ok(deserialize_with) => deserialize_with.0,
3669 Err(err) => {
3670 return Err(err);
3671 }
3672 }
3673 });
3674 }
3675 Field::Review => {
3676 if r#review_property.is_some() {
3677 return Err(<A::Error as de::Error>::duplicate_field("review"));
3678 }
3679 r#review_property = Some({
3680 struct DeserializeWith(Vec<ReviewProperty>);
3681 impl<'de> Deserialize<'de> for DeserializeWith {
3682 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3683 where
3684 D: Deserializer<'de>,
3685 {
3686 Ok(DeserializeWith(serde_with::As::<
3687 serde_with::OneOrMany<serde_with::Same>,
3688 >::deserialize(deserializer)?))
3689 }
3690 }
3691 match map.next_value::<DeserializeWith>() {
3692 Ok(deserialize_with) => deserialize_with.0,
3693 Err(err) => {
3694 return Err(err);
3695 }
3696 }
3697 });
3698 }
3699 Field::Reviews => {
3700 if r#reviews_property.is_some() {
3701 return Err(<A::Error as de::Error>::duplicate_field(
3702 "reviews",
3703 ));
3704 }
3705 r#reviews_property = Some({
3706 struct DeserializeWith(Vec<ReviewsProperty>);
3707 impl<'de> Deserialize<'de> for DeserializeWith {
3708 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3709 where
3710 D: Deserializer<'de>,
3711 {
3712 Ok(DeserializeWith(serde_with::As::<
3713 serde_with::OneOrMany<serde_with::Same>,
3714 >::deserialize(deserializer)?))
3715 }
3716 }
3717 match map.next_value::<DeserializeWith>() {
3718 Ok(deserialize_with) => deserialize_with.0,
3719 Err(err) => {
3720 return Err(err);
3721 }
3722 }
3723 });
3724 }
3725 Field::Size => {
3726 if r#size_property.is_some() {
3727 return Err(<A::Error as de::Error>::duplicate_field("size"));
3728 }
3729 r#size_property = Some({
3730 struct DeserializeWith(Vec<SizeProperty>);
3731 impl<'de> Deserialize<'de> for DeserializeWith {
3732 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3733 where
3734 D: Deserializer<'de>,
3735 {
3736 Ok(DeserializeWith(serde_with::As::<
3737 serde_with::OneOrMany<serde_with::Same>,
3738 >::deserialize(deserializer)?))
3739 }
3740 }
3741 match map.next_value::<DeserializeWith>() {
3742 Ok(deserialize_with) => deserialize_with.0,
3743 Err(err) => {
3744 return Err(err);
3745 }
3746 }
3747 });
3748 }
3749 Field::Sku => {
3750 if r#sku_property.is_some() {
3751 return Err(<A::Error as de::Error>::duplicate_field("sku"));
3752 }
3753 r#sku_property = Some({
3754 struct DeserializeWith(Vec<SkuProperty>);
3755 impl<'de> Deserialize<'de> for DeserializeWith {
3756 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3757 where
3758 D: Deserializer<'de>,
3759 {
3760 Ok(DeserializeWith(serde_with::As::<
3761 serde_with::OneOrMany<serde_with::Same>,
3762 >::deserialize(deserializer)?))
3763 }
3764 }
3765 match map.next_value::<DeserializeWith>() {
3766 Ok(deserialize_with) => deserialize_with.0,
3767 Err(err) => {
3768 return Err(err);
3769 }
3770 }
3771 });
3772 }
3773 Field::Slogan => {
3774 if r#slogan_property.is_some() {
3775 return Err(<A::Error as de::Error>::duplicate_field("slogan"));
3776 }
3777 r#slogan_property = Some({
3778 struct DeserializeWith(Vec<SloganProperty>);
3779 impl<'de> Deserialize<'de> for DeserializeWith {
3780 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3781 where
3782 D: Deserializer<'de>,
3783 {
3784 Ok(DeserializeWith(serde_with::As::<
3785 serde_with::OneOrMany<serde_with::Same>,
3786 >::deserialize(deserializer)?))
3787 }
3788 }
3789 match map.next_value::<DeserializeWith>() {
3790 Ok(deserialize_with) => deserialize_with.0,
3791 Err(err) => {
3792 return Err(err);
3793 }
3794 }
3795 });
3796 }
3797 Field::Weight => {
3798 if r#weight_property.is_some() {
3799 return Err(<A::Error as de::Error>::duplicate_field("weight"));
3800 }
3801 r#weight_property = Some({
3802 struct DeserializeWith(Vec<WeightProperty>);
3803 impl<'de> Deserialize<'de> for DeserializeWith {
3804 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3805 where
3806 D: Deserializer<'de>,
3807 {
3808 Ok(DeserializeWith(serde_with::As::<
3809 serde_with::OneOrMany<serde_with::Same>,
3810 >::deserialize(deserializer)?))
3811 }
3812 }
3813 match map.next_value::<DeserializeWith>() {
3814 Ok(deserialize_with) => deserialize_with.0,
3815 Err(err) => {
3816 return Err(err);
3817 }
3818 }
3819 });
3820 }
3821 Field::Width => {
3822 if r#width_property.is_some() {
3823 return Err(<A::Error as de::Error>::duplicate_field("width"));
3824 }
3825 r#width_property = Some({
3826 struct DeserializeWith(Vec<WidthProperty>);
3827 impl<'de> Deserialize<'de> for DeserializeWith {
3828 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3829 where
3830 D: Deserializer<'de>,
3831 {
3832 Ok(DeserializeWith(serde_with::As::<
3833 serde_with::OneOrMany<serde_with::Same>,
3834 >::deserialize(deserializer)?))
3835 }
3836 }
3837 match map.next_value::<DeserializeWith>() {
3838 Ok(deserialize_with) => deserialize_with.0,
3839 Err(err) => {
3840 return Err(err);
3841 }
3842 }
3843 });
3844 }
3845 Field::AdditionalType => {
3846 if r#additional_type_property.is_some() {
3847 return Err(<A::Error as de::Error>::duplicate_field(
3848 "additionalType",
3849 ));
3850 }
3851 r#additional_type_property = Some({
3852 struct DeserializeWith(Vec<AdditionalTypeProperty>);
3853 impl<'de> Deserialize<'de> for DeserializeWith {
3854 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3855 where
3856 D: Deserializer<'de>,
3857 {
3858 Ok(DeserializeWith(serde_with::As::<
3859 serde_with::OneOrMany<serde_with::Same>,
3860 >::deserialize(deserializer)?))
3861 }
3862 }
3863 match map.next_value::<DeserializeWith>() {
3864 Ok(deserialize_with) => deserialize_with.0,
3865 Err(err) => {
3866 return Err(err);
3867 }
3868 }
3869 });
3870 }
3871 Field::AlternateName => {
3872 if r#alternate_name_property.is_some() {
3873 return Err(<A::Error as de::Error>::duplicate_field(
3874 "alternateName",
3875 ));
3876 }
3877 r#alternate_name_property = Some({
3878 struct DeserializeWith(Vec<AlternateNameProperty>);
3879 impl<'de> Deserialize<'de> for DeserializeWith {
3880 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3881 where
3882 D: Deserializer<'de>,
3883 {
3884 Ok(DeserializeWith(serde_with::As::<
3885 serde_with::OneOrMany<serde_with::Same>,
3886 >::deserialize(deserializer)?))
3887 }
3888 }
3889 match map.next_value::<DeserializeWith>() {
3890 Ok(deserialize_with) => deserialize_with.0,
3891 Err(err) => {
3892 return Err(err);
3893 }
3894 }
3895 });
3896 }
3897 Field::Description => {
3898 if r#description_property.is_some() {
3899 return Err(<A::Error as de::Error>::duplicate_field(
3900 "description",
3901 ));
3902 }
3903 r#description_property = Some({
3904 struct DeserializeWith(Vec<DescriptionProperty>);
3905 impl<'de> Deserialize<'de> for DeserializeWith {
3906 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3907 where
3908 D: Deserializer<'de>,
3909 {
3910 Ok(DeserializeWith(serde_with::As::<
3911 serde_with::OneOrMany<serde_with::Same>,
3912 >::deserialize(deserializer)?))
3913 }
3914 }
3915 match map.next_value::<DeserializeWith>() {
3916 Ok(deserialize_with) => deserialize_with.0,
3917 Err(err) => {
3918 return Err(err);
3919 }
3920 }
3921 });
3922 }
3923 Field::DisambiguatingDescription => {
3924 if r#disambiguating_description_property.is_some() {
3925 return Err(<A::Error as de::Error>::duplicate_field(
3926 "disambiguatingDescription",
3927 ));
3928 }
3929 r#disambiguating_description_property = Some({
3930 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
3931 impl<'de> Deserialize<'de> for DeserializeWith {
3932 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3933 where
3934 D: Deserializer<'de>,
3935 {
3936 Ok(DeserializeWith(serde_with::As::<
3937 serde_with::OneOrMany<serde_with::Same>,
3938 >::deserialize(deserializer)?))
3939 }
3940 }
3941 match map.next_value::<DeserializeWith>() {
3942 Ok(deserialize_with) => deserialize_with.0,
3943 Err(err) => {
3944 return Err(err);
3945 }
3946 }
3947 });
3948 }
3949 Field::Identifier => {
3950 if r#identifier_property.is_some() {
3951 return Err(<A::Error as de::Error>::duplicate_field(
3952 "identifier",
3953 ));
3954 }
3955 r#identifier_property = Some({
3956 struct DeserializeWith(Vec<IdentifierProperty>);
3957 impl<'de> Deserialize<'de> for DeserializeWith {
3958 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3959 where
3960 D: Deserializer<'de>,
3961 {
3962 Ok(DeserializeWith(serde_with::As::<
3963 serde_with::OneOrMany<serde_with::Same>,
3964 >::deserialize(deserializer)?))
3965 }
3966 }
3967 match map.next_value::<DeserializeWith>() {
3968 Ok(deserialize_with) => deserialize_with.0,
3969 Err(err) => {
3970 return Err(err);
3971 }
3972 }
3973 });
3974 }
3975 Field::Image => {
3976 if r#image_property.is_some() {
3977 return Err(<A::Error as de::Error>::duplicate_field("image"));
3978 }
3979 r#image_property = Some({
3980 struct DeserializeWith(Vec<ImageProperty>);
3981 impl<'de> Deserialize<'de> for DeserializeWith {
3982 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3983 where
3984 D: Deserializer<'de>,
3985 {
3986 Ok(DeserializeWith(serde_with::As::<
3987 serde_with::OneOrMany<serde_with::Same>,
3988 >::deserialize(deserializer)?))
3989 }
3990 }
3991 match map.next_value::<DeserializeWith>() {
3992 Ok(deserialize_with) => deserialize_with.0,
3993 Err(err) => {
3994 return Err(err);
3995 }
3996 }
3997 });
3998 }
3999 Field::MainEntityOfPage => {
4000 if r#main_entity_of_page_property.is_some() {
4001 return Err(<A::Error as de::Error>::duplicate_field(
4002 "mainEntityOfPage",
4003 ));
4004 }
4005 r#main_entity_of_page_property = Some({
4006 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
4007 impl<'de> Deserialize<'de> for DeserializeWith {
4008 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4009 where
4010 D: Deserializer<'de>,
4011 {
4012 Ok(DeserializeWith(serde_with::As::<
4013 serde_with::OneOrMany<serde_with::Same>,
4014 >::deserialize(deserializer)?))
4015 }
4016 }
4017 match map.next_value::<DeserializeWith>() {
4018 Ok(deserialize_with) => deserialize_with.0,
4019 Err(err) => {
4020 return Err(err);
4021 }
4022 }
4023 });
4024 }
4025 Field::Name => {
4026 if r#name_property.is_some() {
4027 return Err(<A::Error as de::Error>::duplicate_field("name"));
4028 }
4029 r#name_property = Some({
4030 struct DeserializeWith(Vec<NameProperty>);
4031 impl<'de> Deserialize<'de> for DeserializeWith {
4032 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4033 where
4034 D: Deserializer<'de>,
4035 {
4036 Ok(DeserializeWith(serde_with::As::<
4037 serde_with::OneOrMany<serde_with::Same>,
4038 >::deserialize(deserializer)?))
4039 }
4040 }
4041 match map.next_value::<DeserializeWith>() {
4042 Ok(deserialize_with) => deserialize_with.0,
4043 Err(err) => {
4044 return Err(err);
4045 }
4046 }
4047 });
4048 }
4049 Field::PotentialAction => {
4050 if r#potential_action_property.is_some() {
4051 return Err(<A::Error as de::Error>::duplicate_field(
4052 "potentialAction",
4053 ));
4054 }
4055 r#potential_action_property = Some({
4056 struct DeserializeWith(Vec<PotentialActionProperty>);
4057 impl<'de> Deserialize<'de> for DeserializeWith {
4058 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4059 where
4060 D: Deserializer<'de>,
4061 {
4062 Ok(DeserializeWith(serde_with::As::<
4063 serde_with::OneOrMany<serde_with::Same>,
4064 >::deserialize(deserializer)?))
4065 }
4066 }
4067 match map.next_value::<DeserializeWith>() {
4068 Ok(deserialize_with) => deserialize_with.0,
4069 Err(err) => {
4070 return Err(err);
4071 }
4072 }
4073 });
4074 }
4075 Field::SameAs => {
4076 if r#same_as_property.is_some() {
4077 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
4078 }
4079 r#same_as_property = Some({
4080 struct DeserializeWith(Vec<SameAsProperty>);
4081 impl<'de> Deserialize<'de> for DeserializeWith {
4082 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4083 where
4084 D: Deserializer<'de>,
4085 {
4086 Ok(DeserializeWith(serde_with::As::<
4087 serde_with::OneOrMany<serde_with::Same>,
4088 >::deserialize(deserializer)?))
4089 }
4090 }
4091 match map.next_value::<DeserializeWith>() {
4092 Ok(deserialize_with) => deserialize_with.0,
4093 Err(err) => {
4094 return Err(err);
4095 }
4096 }
4097 });
4098 }
4099 Field::SubjectOf => {
4100 if r#subject_of_property.is_some() {
4101 return Err(<A::Error as de::Error>::duplicate_field(
4102 "subjectOf",
4103 ));
4104 }
4105 r#subject_of_property = Some({
4106 struct DeserializeWith(Vec<SubjectOfProperty>);
4107 impl<'de> Deserialize<'de> for DeserializeWith {
4108 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4109 where
4110 D: Deserializer<'de>,
4111 {
4112 Ok(DeserializeWith(serde_with::As::<
4113 serde_with::OneOrMany<serde_with::Same>,
4114 >::deserialize(deserializer)?))
4115 }
4116 }
4117 match map.next_value::<DeserializeWith>() {
4118 Ok(deserialize_with) => deserialize_with.0,
4119 Err(err) => {
4120 return Err(err);
4121 }
4122 }
4123 });
4124 }
4125 Field::Url => {
4126 if r#url_property.is_some() {
4127 return Err(<A::Error as de::Error>::duplicate_field("url"));
4128 }
4129 r#url_property = Some({
4130 struct DeserializeWith(Vec<UrlProperty>);
4131 impl<'de> Deserialize<'de> for DeserializeWith {
4132 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4133 where
4134 D: Deserializer<'de>,
4135 {
4136 Ok(DeserializeWith(serde_with::As::<
4137 serde_with::OneOrMany<serde_with::Same>,
4138 >::deserialize(deserializer)?))
4139 }
4140 }
4141 match map.next_value::<DeserializeWith>() {
4142 Ok(deserialize_with) => deserialize_with.0,
4143 Err(err) => {
4144 return Err(err);
4145 }
4146 }
4147 });
4148 }
4149 Field::Ignore => {
4150 let _ = map.next_value::<de::IgnoredAny>()?;
4151 }
4152 }
4153 }
4154 Ok(Product {
4155 r#additional_property: r#additional_property_property.unwrap_or_default(),
4156 r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
4157 r#asin: r#asin_property.unwrap_or_default(),
4158 r#audience: r#audience_property.unwrap_or_default(),
4159 r#award: r#award_property.unwrap_or_default(),
4160 r#awards: r#awards_property.unwrap_or_default(),
4161 r#brand: r#brand_property.unwrap_or_default(),
4162 r#category: r#category_property.unwrap_or_default(),
4163 r#color: r#color_property.unwrap_or_default(),
4164 r#country_of_assembly: r#country_of_assembly_property.unwrap_or_default(),
4165 r#country_of_last_processing: r#country_of_last_processing_property
4166 .unwrap_or_default(),
4167 r#country_of_origin: r#country_of_origin_property.unwrap_or_default(),
4168 r#depth: r#depth_property.unwrap_or_default(),
4169 r#funding: r#funding_property.unwrap_or_default(),
4170 r#gtin: r#gtin_property.unwrap_or_default(),
4171 r#gtin_12: r#gtin_12_property.unwrap_or_default(),
4172 r#gtin_13: r#gtin_13_property.unwrap_or_default(),
4173 r#gtin_14: r#gtin_14_property.unwrap_or_default(),
4174 r#gtin_8: r#gtin_8_property.unwrap_or_default(),
4175 r#has_adult_consideration: r#has_adult_consideration_property
4176 .unwrap_or_default(),
4177 r#has_energy_consumption_details: r#has_energy_consumption_details_property
4178 .unwrap_or_default(),
4179 r#has_measurement: r#has_measurement_property.unwrap_or_default(),
4180 r#has_merchant_return_policy: r#has_merchant_return_policy_property
4181 .unwrap_or_default(),
4182 r#has_product_return_policy: r#has_product_return_policy_property
4183 .unwrap_or_default(),
4184 r#height: r#height_property.unwrap_or_default(),
4185 r#in_product_group_with_id: r#in_product_group_with_id_property
4186 .unwrap_or_default(),
4187 r#is_accessory_or_spare_part_for: r#is_accessory_or_spare_part_for_property
4188 .unwrap_or_default(),
4189 r#is_consumable_for: r#is_consumable_for_property.unwrap_or_default(),
4190 r#is_family_friendly: r#is_family_friendly_property.unwrap_or_default(),
4191 r#is_related_to: r#is_related_to_property.unwrap_or_default(),
4192 r#is_similar_to: r#is_similar_to_property.unwrap_or_default(),
4193 r#is_variant_of: r#is_variant_of_property.unwrap_or_default(),
4194 r#item_condition: r#item_condition_property.unwrap_or_default(),
4195 r#keywords: r#keywords_property.unwrap_or_default(),
4196 r#logo: r#logo_property.unwrap_or_default(),
4197 r#manufacturer: r#manufacturer_property.unwrap_or_default(),
4198 r#material: r#material_property.unwrap_or_default(),
4199 r#mobile_url: r#mobile_url_property.unwrap_or_default(),
4200 r#model: r#model_property.unwrap_or_default(),
4201 r#mpn: r#mpn_property.unwrap_or_default(),
4202 r#negative_notes: r#negative_notes_property.unwrap_or_default(),
4203 r#nsn: r#nsn_property.unwrap_or_default(),
4204 r#offers: r#offers_property.unwrap_or_default(),
4205 r#pattern: r#pattern_property.unwrap_or_default(),
4206 r#positive_notes: r#positive_notes_property.unwrap_or_default(),
4207 r#product_id: r#product_id_property.unwrap_or_default(),
4208 r#production_date: r#production_date_property.unwrap_or_default(),
4209 r#purchase_date: r#purchase_date_property.unwrap_or_default(),
4210 r#release_date: r#release_date_property.unwrap_or_default(),
4211 r#review: r#review_property.unwrap_or_default(),
4212 r#reviews: r#reviews_property.unwrap_or_default(),
4213 r#size: r#size_property.unwrap_or_default(),
4214 r#sku: r#sku_property.unwrap_or_default(),
4215 r#slogan: r#slogan_property.unwrap_or_default(),
4216 r#weight: r#weight_property.unwrap_or_default(),
4217 r#width: r#width_property.unwrap_or_default(),
4218 r#additional_type: r#additional_type_property.unwrap_or_default(),
4219 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
4220 r#description: r#description_property.unwrap_or_default(),
4221 r#disambiguating_description: r#disambiguating_description_property
4222 .unwrap_or_default(),
4223 r#identifier: r#identifier_property.unwrap_or_default(),
4224 r#image: r#image_property.unwrap_or_default(),
4225 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
4226 r#name: r#name_property.unwrap_or_default(),
4227 r#potential_action: r#potential_action_property.unwrap_or_default(),
4228 r#same_as: r#same_as_property.unwrap_or_default(),
4229 r#subject_of: r#subject_of_property.unwrap_or_default(),
4230 r#url: r#url_property.unwrap_or_default(),
4231 })
4232 }
4233 }
4234 const FIELDS: &[&str] = &[
4235 "additionalProperty",
4236 "aggregateRating",
4237 "asin",
4238 "audience",
4239 "award",
4240 "awards",
4241 "brand",
4242 "category",
4243 "color",
4244 "countryOfAssembly",
4245 "countryOfLastProcessing",
4246 "countryOfOrigin",
4247 "depth",
4248 "funding",
4249 "gtin",
4250 "gtin12",
4251 "gtin13",
4252 "gtin14",
4253 "gtin8",
4254 "hasAdultConsideration",
4255 "hasEnergyConsumptionDetails",
4256 "hasMeasurement",
4257 "hasMerchantReturnPolicy",
4258 "hasProductReturnPolicy",
4259 "height",
4260 "inProductGroupWithID",
4261 "isAccessoryOrSparePartFor",
4262 "isConsumableFor",
4263 "isFamilyFriendly",
4264 "isRelatedTo",
4265 "isSimilarTo",
4266 "isVariantOf",
4267 "itemCondition",
4268 "keywords",
4269 "logo",
4270 "manufacturer",
4271 "material",
4272 "mobileUrl",
4273 "model",
4274 "mpn",
4275 "negativeNotes",
4276 "nsn",
4277 "offers",
4278 "pattern",
4279 "positiveNotes",
4280 "productID",
4281 "productionDate",
4282 "purchaseDate",
4283 "releaseDate",
4284 "review",
4285 "reviews",
4286 "size",
4287 "sku",
4288 "slogan",
4289 "weight",
4290 "width",
4291 "additionalType",
4292 "alternateName",
4293 "description",
4294 "disambiguatingDescription",
4295 "identifier",
4296 "image",
4297 "mainEntityOfPage",
4298 "name",
4299 "potentialAction",
4300 "sameAs",
4301 "subjectOf",
4302 "url",
4303 ];
4304 deserializer.deserialize_struct("Product", FIELDS, ClassVisitor)
4305 }
4306 }
4307}