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