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