schema_org_types/schemas/classes/
offer.rs

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