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