schema_org_types/schemas/classes/
motorcycle.rs

1use super::*;
2/// <https://schema.org/Motorcycle>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Motorcycle {
6	/// <https://schema.org/additionalProperty>
7	pub r#additional_property: Vec<AdditionalPropertyProperty>,
8	/// <https://schema.org/aggregateRating>
9	pub r#aggregate_rating: Vec<AggregateRatingProperty>,
10	/// <https://schema.org/asin>
11	pub r#asin: Vec<AsinProperty>,
12	/// <https://schema.org/audience>
13	pub r#audience: Vec<AudienceProperty>,
14	/// <https://schema.org/award>
15	pub r#award: Vec<AwardProperty>,
16	/// <https://schema.org/awards>
17	#[deprecated = "This schema is superseded by <https://schema.org/award>."]
18	pub r#awards: Vec<AwardsProperty>,
19	/// <https://schema.org/brand>
20	pub r#brand: Vec<BrandProperty>,
21	/// <https://schema.org/category>
22	pub r#category: Vec<CategoryProperty>,
23	/// <https://schema.org/color>
24	pub r#color: Vec<ColorProperty>,
25	/// <https://schema.org/countryOfAssembly>
26	pub r#country_of_assembly: Vec<CountryOfAssemblyProperty>,
27	/// <https://schema.org/countryOfLastProcessing>
28	pub r#country_of_last_processing: Vec<CountryOfLastProcessingProperty>,
29	/// <https://schema.org/countryOfOrigin>
30	pub r#country_of_origin: Vec<CountryOfOriginProperty>,
31	/// <https://schema.org/depth>
32	pub r#depth: Vec<DepthProperty>,
33	/// <https://schema.org/funding>
34	pub r#funding: Vec<FundingProperty>,
35	/// <https://schema.org/gtin>
36	pub r#gtin: Vec<GtinProperty>,
37	/// <https://schema.org/gtin12>
38	pub r#gtin_12: Vec<Gtin12Property>,
39	/// <https://schema.org/gtin13>
40	pub r#gtin_13: Vec<Gtin13Property>,
41	/// <https://schema.org/gtin14>
42	pub r#gtin_14: Vec<Gtin14Property>,
43	/// <https://schema.org/gtin8>
44	pub r#gtin_8: Vec<Gtin8Property>,
45	/// <https://schema.org/hasAdultConsideration>
46	pub r#has_adult_consideration: Vec<HasAdultConsiderationProperty>,
47	/// <https://schema.org/hasEnergyConsumptionDetails>
48	pub r#has_energy_consumption_details: Vec<HasEnergyConsumptionDetailsProperty>,
49	/// <https://schema.org/hasMeasurement>
50	pub r#has_measurement: Vec<HasMeasurementProperty>,
51	/// <https://schema.org/hasMerchantReturnPolicy>
52	pub r#has_merchant_return_policy: Vec<HasMerchantReturnPolicyProperty>,
53	/// <https://schema.org/hasProductReturnPolicy>
54	#[deprecated = "This schema is archived, see <https://schema.org/docs/attic.home.html>. This schema is superseded by <https://schema.org/hasMerchantReturnPolicy>."]
55	pub r#has_product_return_policy: Vec<HasProductReturnPolicyProperty>,
56	/// <https://schema.org/height>
57	pub r#height: Vec<HeightProperty>,
58	/// <https://schema.org/inProductGroupWithID>
59	pub r#in_product_group_with_id: Vec<InProductGroupWithIdProperty>,
60	/// <https://schema.org/isAccessoryOrSparePartFor>
61	pub r#is_accessory_or_spare_part_for: Vec<IsAccessoryOrSparePartForProperty>,
62	/// <https://schema.org/isConsumableFor>
63	pub r#is_consumable_for: Vec<IsConsumableForProperty>,
64	/// <https://schema.org/isFamilyFriendly>
65	pub r#is_family_friendly: Vec<IsFamilyFriendlyProperty>,
66	/// <https://schema.org/isRelatedTo>
67	pub r#is_related_to: Vec<IsRelatedToProperty>,
68	/// <https://schema.org/isSimilarTo>
69	pub r#is_similar_to: Vec<IsSimilarToProperty>,
70	/// <https://schema.org/isVariantOf>
71	pub r#is_variant_of: Vec<IsVariantOfProperty>,
72	/// <https://schema.org/itemCondition>
73	pub r#item_condition: Vec<ItemConditionProperty>,
74	/// <https://schema.org/keywords>
75	pub r#keywords: Vec<KeywordsProperty>,
76	/// <https://schema.org/logo>
77	pub r#logo: Vec<LogoProperty>,
78	/// <https://schema.org/manufacturer>
79	pub r#manufacturer: Vec<ManufacturerProperty>,
80	/// <https://schema.org/material>
81	pub r#material: Vec<MaterialProperty>,
82	/// <https://schema.org/mobileUrl>
83	pub r#mobile_url: Vec<MobileUrlProperty>,
84	/// <https://schema.org/model>
85	pub r#model: Vec<ModelProperty>,
86	/// <https://schema.org/mpn>
87	pub r#mpn: Vec<MpnProperty>,
88	/// <https://schema.org/negativeNotes>
89	pub r#negative_notes: Vec<NegativeNotesProperty>,
90	/// <https://schema.org/nsn>
91	pub r#nsn: Vec<NsnProperty>,
92	/// <https://schema.org/offers>
93	pub r#offers: Vec<OffersProperty>,
94	/// <https://schema.org/pattern>
95	pub r#pattern: Vec<PatternProperty>,
96	/// <https://schema.org/positiveNotes>
97	pub r#positive_notes: Vec<PositiveNotesProperty>,
98	/// <https://schema.org/productID>
99	pub r#product_id: Vec<ProductIdProperty>,
100	/// <https://schema.org/productionDate>
101	pub r#production_date: Vec<ProductionDateProperty>,
102	/// <https://schema.org/purchaseDate>
103	pub r#purchase_date: Vec<PurchaseDateProperty>,
104	/// <https://schema.org/releaseDate>
105	pub r#release_date: Vec<ReleaseDateProperty>,
106	/// <https://schema.org/review>
107	pub r#review: Vec<ReviewProperty>,
108	/// <https://schema.org/reviews>
109	#[deprecated = "This schema is superseded by <https://schema.org/review>."]
110	pub r#reviews: Vec<ReviewsProperty>,
111	/// <https://schema.org/size>
112	pub r#size: Vec<SizeProperty>,
113	/// <https://schema.org/sku>
114	pub r#sku: Vec<SkuProperty>,
115	/// <https://schema.org/slogan>
116	pub r#slogan: Vec<SloganProperty>,
117	/// <https://schema.org/weight>
118	pub r#weight: Vec<WeightProperty>,
119	/// <https://schema.org/width>
120	pub r#width: Vec<WidthProperty>,
121	/// <https://schema.org/additionalType>
122	pub r#additional_type: Vec<AdditionalTypeProperty>,
123	/// <https://schema.org/alternateName>
124	pub r#alternate_name: Vec<AlternateNameProperty>,
125	/// <https://schema.org/description>
126	pub r#description: Vec<DescriptionProperty>,
127	/// <https://schema.org/disambiguatingDescription>
128	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
129	/// <https://schema.org/identifier>
130	pub r#identifier: Vec<IdentifierProperty>,
131	/// <https://schema.org/image>
132	pub r#image: Vec<ImageProperty>,
133	/// <https://schema.org/mainEntityOfPage>
134	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
135	/// <https://schema.org/name>
136	pub r#name: Vec<NameProperty>,
137	/// <https://schema.org/potentialAction>
138	pub r#potential_action: Vec<PotentialActionProperty>,
139	/// <https://schema.org/sameAs>
140	pub r#same_as: Vec<SameAsProperty>,
141	/// <https://schema.org/subjectOf>
142	pub r#subject_of: Vec<SubjectOfProperty>,
143	/// <https://schema.org/url>
144	pub r#url: Vec<UrlProperty>,
145	/// <https://schema.org/accelerationTime>
146	pub r#acceleration_time: Vec<AccelerationTimeProperty>,
147	/// <https://schema.org/bodyType>
148	pub r#body_type: Vec<BodyTypeProperty>,
149	/// <https://schema.org/callSign>
150	pub r#call_sign: Vec<CallSignProperty>,
151	/// <https://schema.org/cargoVolume>
152	pub r#cargo_volume: Vec<CargoVolumeProperty>,
153	/// <https://schema.org/dateVehicleFirstRegistered>
154	pub r#date_vehicle_first_registered: Vec<DateVehicleFirstRegisteredProperty>,
155	/// <https://schema.org/driveWheelConfiguration>
156	pub r#drive_wheel_configuration: Vec<DriveWheelConfigurationProperty>,
157	/// <https://schema.org/emissionsCO2>
158	pub r#emissions_co_2: Vec<EmissionsCo2Property>,
159	/// <https://schema.org/fuelCapacity>
160	pub r#fuel_capacity: Vec<FuelCapacityProperty>,
161	/// <https://schema.org/fuelConsumption>
162	pub r#fuel_consumption: Vec<FuelConsumptionProperty>,
163	/// <https://schema.org/fuelEfficiency>
164	pub r#fuel_efficiency: Vec<FuelEfficiencyProperty>,
165	/// <https://schema.org/fuelType>
166	pub r#fuel_type: Vec<FuelTypeProperty>,
167	/// <https://schema.org/knownVehicleDamages>
168	pub r#known_vehicle_damages: Vec<KnownVehicleDamagesProperty>,
169	/// <https://schema.org/meetsEmissionStandard>
170	pub r#meets_emission_standard: Vec<MeetsEmissionStandardProperty>,
171	/// <https://schema.org/mileageFromOdometer>
172	pub r#mileage_from_odometer: Vec<MileageFromOdometerProperty>,
173	/// <https://schema.org/modelDate>
174	pub r#model_date: Vec<ModelDateProperty>,
175	/// <https://schema.org/numberOfAirbags>
176	pub r#number_of_airbags: Vec<NumberOfAirbagsProperty>,
177	/// <https://schema.org/numberOfAxles>
178	pub r#number_of_axles: Vec<NumberOfAxlesProperty>,
179	/// <https://schema.org/numberOfDoors>
180	pub r#number_of_doors: Vec<NumberOfDoorsProperty>,
181	/// <https://schema.org/numberOfForwardGears>
182	pub r#number_of_forward_gears: Vec<NumberOfForwardGearsProperty>,
183	/// <https://schema.org/numberOfPreviousOwners>
184	pub r#number_of_previous_owners: Vec<NumberOfPreviousOwnersProperty>,
185	/// <https://schema.org/payload>
186	pub r#payload: Vec<PayloadProperty>,
187	/// <https://schema.org/seatingCapacity>
188	pub r#seating_capacity: Vec<SeatingCapacityProperty>,
189	/// <https://schema.org/speed>
190	pub r#speed: Vec<SpeedProperty>,
191	/// <https://schema.org/steeringPosition>
192	pub r#steering_position: Vec<SteeringPositionProperty>,
193	/// <https://schema.org/stupidProperty>
194	#[deprecated = "This schema is archived, see <https://schema.org/docs/attic.home.html>."]
195	pub r#stupid_property: Vec<StupidPropertyProperty>,
196	/// <https://schema.org/tongueWeight>
197	pub r#tongue_weight: Vec<TongueWeightProperty>,
198	/// <https://schema.org/trailerWeight>
199	pub r#trailer_weight: Vec<TrailerWeightProperty>,
200	/// <https://schema.org/vehicleConfiguration>
201	pub r#vehicle_configuration: Vec<VehicleConfigurationProperty>,
202	/// <https://schema.org/vehicleEngine>
203	pub r#vehicle_engine: Vec<VehicleEngineProperty>,
204	/// <https://schema.org/vehicleIdentificationNumber>
205	pub r#vehicle_identification_number: Vec<VehicleIdentificationNumberProperty>,
206	/// <https://schema.org/vehicleInteriorColor>
207	pub r#vehicle_interior_color: Vec<VehicleInteriorColorProperty>,
208	/// <https://schema.org/vehicleInteriorType>
209	pub r#vehicle_interior_type: Vec<VehicleInteriorTypeProperty>,
210	/// <https://schema.org/vehicleModelDate>
211	pub r#vehicle_model_date: Vec<VehicleModelDateProperty>,
212	/// <https://schema.org/vehicleSeatingCapacity>
213	pub r#vehicle_seating_capacity: Vec<VehicleSeatingCapacityProperty>,
214	/// <https://schema.org/vehicleSpecialUsage>
215	pub r#vehicle_special_usage: Vec<VehicleSpecialUsageProperty>,
216	/// <https://schema.org/vehicleTransmission>
217	pub r#vehicle_transmission: Vec<VehicleTransmissionProperty>,
218	/// <https://schema.org/weightTotal>
219	pub r#weight_total: Vec<WeightTotalProperty>,
220	/// <https://schema.org/wheelbase>
221	pub r#wheelbase: Vec<WheelbaseProperty>,
222}
223/// This trait is for properties from <https://schema.org/Motorcycle>.
224pub trait MotorcycleTrait {}
225impl MotorcycleTrait for Motorcycle {}
226impl ProductTrait for Motorcycle {
227	fn get_additional_property(&self) -> &[AdditionalPropertyProperty] {
228		self.r#additional_property.as_slice()
229	}
230	fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty> {
231		std::mem::take(&mut self.r#additional_property)
232	}
233	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
234		self.r#aggregate_rating.as_slice()
235	}
236	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
237		std::mem::take(&mut self.r#aggregate_rating)
238	}
239	fn get_asin(&self) -> &[AsinProperty] {
240		self.r#asin.as_slice()
241	}
242	fn take_asin(&mut self) -> Vec<AsinProperty> {
243		std::mem::take(&mut self.r#asin)
244	}
245	fn get_audience(&self) -> &[AudienceProperty] {
246		self.r#audience.as_slice()
247	}
248	fn take_audience(&mut self) -> Vec<AudienceProperty> {
249		std::mem::take(&mut self.r#audience)
250	}
251	fn get_award(&self) -> &[AwardProperty] {
252		self.r#award.as_slice()
253	}
254	fn take_award(&mut self) -> Vec<AwardProperty> {
255		std::mem::take(&mut self.r#award)
256	}
257	fn get_awards(&self) -> &[AwardsProperty] {
258		self.r#awards.as_slice()
259	}
260	fn take_awards(&mut self) -> Vec<AwardsProperty> {
261		std::mem::take(&mut self.r#awards)
262	}
263	fn get_brand(&self) -> &[BrandProperty] {
264		self.r#brand.as_slice()
265	}
266	fn take_brand(&mut self) -> Vec<BrandProperty> {
267		std::mem::take(&mut self.r#brand)
268	}
269	fn get_category(&self) -> &[CategoryProperty] {
270		self.r#category.as_slice()
271	}
272	fn take_category(&mut self) -> Vec<CategoryProperty> {
273		std::mem::take(&mut self.r#category)
274	}
275	fn get_color(&self) -> &[ColorProperty] {
276		self.r#color.as_slice()
277	}
278	fn take_color(&mut self) -> Vec<ColorProperty> {
279		std::mem::take(&mut self.r#color)
280	}
281	fn get_country_of_assembly(&self) -> &[CountryOfAssemblyProperty] {
282		self.r#country_of_assembly.as_slice()
283	}
284	fn take_country_of_assembly(&mut self) -> Vec<CountryOfAssemblyProperty> {
285		std::mem::take(&mut self.r#country_of_assembly)
286	}
287	fn get_country_of_last_processing(&self) -> &[CountryOfLastProcessingProperty] {
288		self.r#country_of_last_processing.as_slice()
289	}
290	fn take_country_of_last_processing(&mut self) -> Vec<CountryOfLastProcessingProperty> {
291		std::mem::take(&mut self.r#country_of_last_processing)
292	}
293	fn get_country_of_origin(&self) -> &[CountryOfOriginProperty] {
294		self.r#country_of_origin.as_slice()
295	}
296	fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty> {
297		std::mem::take(&mut self.r#country_of_origin)
298	}
299	fn get_depth(&self) -> &[DepthProperty] {
300		self.r#depth.as_slice()
301	}
302	fn take_depth(&mut self) -> Vec<DepthProperty> {
303		std::mem::take(&mut self.r#depth)
304	}
305	fn get_funding(&self) -> &[FundingProperty] {
306		self.r#funding.as_slice()
307	}
308	fn take_funding(&mut self) -> Vec<FundingProperty> {
309		std::mem::take(&mut self.r#funding)
310	}
311	fn get_gtin(&self) -> &[GtinProperty] {
312		self.r#gtin.as_slice()
313	}
314	fn take_gtin(&mut self) -> Vec<GtinProperty> {
315		std::mem::take(&mut self.r#gtin)
316	}
317	fn get_gtin_12(&self) -> &[Gtin12Property] {
318		self.r#gtin_12.as_slice()
319	}
320	fn take_gtin_12(&mut self) -> Vec<Gtin12Property> {
321		std::mem::take(&mut self.r#gtin_12)
322	}
323	fn get_gtin_13(&self) -> &[Gtin13Property] {
324		self.r#gtin_13.as_slice()
325	}
326	fn take_gtin_13(&mut self) -> Vec<Gtin13Property> {
327		std::mem::take(&mut self.r#gtin_13)
328	}
329	fn get_gtin_14(&self) -> &[Gtin14Property] {
330		self.r#gtin_14.as_slice()
331	}
332	fn take_gtin_14(&mut self) -> Vec<Gtin14Property> {
333		std::mem::take(&mut self.r#gtin_14)
334	}
335	fn get_gtin_8(&self) -> &[Gtin8Property] {
336		self.r#gtin_8.as_slice()
337	}
338	fn take_gtin_8(&mut self) -> Vec<Gtin8Property> {
339		std::mem::take(&mut self.r#gtin_8)
340	}
341	fn get_has_adult_consideration(&self) -> &[HasAdultConsiderationProperty] {
342		self.r#has_adult_consideration.as_slice()
343	}
344	fn take_has_adult_consideration(&mut self) -> Vec<HasAdultConsiderationProperty> {
345		std::mem::take(&mut self.r#has_adult_consideration)
346	}
347	fn get_has_energy_consumption_details(&self) -> &[HasEnergyConsumptionDetailsProperty] {
348		self.r#has_energy_consumption_details.as_slice()
349	}
350	fn take_has_energy_consumption_details(&mut self) -> Vec<HasEnergyConsumptionDetailsProperty> {
351		std::mem::take(&mut self.r#has_energy_consumption_details)
352	}
353	fn get_has_measurement(&self) -> &[HasMeasurementProperty] {
354		self.r#has_measurement.as_slice()
355	}
356	fn take_has_measurement(&mut self) -> Vec<HasMeasurementProperty> {
357		std::mem::take(&mut self.r#has_measurement)
358	}
359	fn get_has_merchant_return_policy(&self) -> &[HasMerchantReturnPolicyProperty] {
360		self.r#has_merchant_return_policy.as_slice()
361	}
362	fn take_has_merchant_return_policy(&mut self) -> Vec<HasMerchantReturnPolicyProperty> {
363		std::mem::take(&mut self.r#has_merchant_return_policy)
364	}
365	fn get_has_product_return_policy(&self) -> &[HasProductReturnPolicyProperty] {
366		self.r#has_product_return_policy.as_slice()
367	}
368	fn take_has_product_return_policy(&mut self) -> Vec<HasProductReturnPolicyProperty> {
369		std::mem::take(&mut self.r#has_product_return_policy)
370	}
371	fn get_height(&self) -> &[HeightProperty] {
372		self.r#height.as_slice()
373	}
374	fn take_height(&mut self) -> Vec<HeightProperty> {
375		std::mem::take(&mut self.r#height)
376	}
377	fn get_in_product_group_with_id(&self) -> &[InProductGroupWithIdProperty] {
378		self.r#in_product_group_with_id.as_slice()
379	}
380	fn take_in_product_group_with_id(&mut self) -> Vec<InProductGroupWithIdProperty> {
381		std::mem::take(&mut self.r#in_product_group_with_id)
382	}
383	fn get_is_accessory_or_spare_part_for(&self) -> &[IsAccessoryOrSparePartForProperty] {
384		self.r#is_accessory_or_spare_part_for.as_slice()
385	}
386	fn take_is_accessory_or_spare_part_for(&mut self) -> Vec<IsAccessoryOrSparePartForProperty> {
387		std::mem::take(&mut self.r#is_accessory_or_spare_part_for)
388	}
389	fn get_is_consumable_for(&self) -> &[IsConsumableForProperty] {
390		self.r#is_consumable_for.as_slice()
391	}
392	fn take_is_consumable_for(&mut self) -> Vec<IsConsumableForProperty> {
393		std::mem::take(&mut self.r#is_consumable_for)
394	}
395	fn get_is_family_friendly(&self) -> &[IsFamilyFriendlyProperty] {
396		self.r#is_family_friendly.as_slice()
397	}
398	fn take_is_family_friendly(&mut self) -> Vec<IsFamilyFriendlyProperty> {
399		std::mem::take(&mut self.r#is_family_friendly)
400	}
401	fn get_is_related_to(&self) -> &[IsRelatedToProperty] {
402		self.r#is_related_to.as_slice()
403	}
404	fn take_is_related_to(&mut self) -> Vec<IsRelatedToProperty> {
405		std::mem::take(&mut self.r#is_related_to)
406	}
407	fn get_is_similar_to(&self) -> &[IsSimilarToProperty] {
408		self.r#is_similar_to.as_slice()
409	}
410	fn take_is_similar_to(&mut self) -> Vec<IsSimilarToProperty> {
411		std::mem::take(&mut self.r#is_similar_to)
412	}
413	fn get_is_variant_of(&self) -> &[IsVariantOfProperty] {
414		self.r#is_variant_of.as_slice()
415	}
416	fn take_is_variant_of(&mut self) -> Vec<IsVariantOfProperty> {
417		std::mem::take(&mut self.r#is_variant_of)
418	}
419	fn get_item_condition(&self) -> &[ItemConditionProperty] {
420		self.r#item_condition.as_slice()
421	}
422	fn take_item_condition(&mut self) -> Vec<ItemConditionProperty> {
423		std::mem::take(&mut self.r#item_condition)
424	}
425	fn get_keywords(&self) -> &[KeywordsProperty] {
426		self.r#keywords.as_slice()
427	}
428	fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
429		std::mem::take(&mut self.r#keywords)
430	}
431	fn get_logo(&self) -> &[LogoProperty] {
432		self.r#logo.as_slice()
433	}
434	fn take_logo(&mut self) -> Vec<LogoProperty> {
435		std::mem::take(&mut self.r#logo)
436	}
437	fn get_manufacturer(&self) -> &[ManufacturerProperty] {
438		self.r#manufacturer.as_slice()
439	}
440	fn take_manufacturer(&mut self) -> Vec<ManufacturerProperty> {
441		std::mem::take(&mut self.r#manufacturer)
442	}
443	fn get_material(&self) -> &[MaterialProperty] {
444		self.r#material.as_slice()
445	}
446	fn take_material(&mut self) -> Vec<MaterialProperty> {
447		std::mem::take(&mut self.r#material)
448	}
449	fn get_mobile_url(&self) -> &[MobileUrlProperty] {
450		self.r#mobile_url.as_slice()
451	}
452	fn take_mobile_url(&mut self) -> Vec<MobileUrlProperty> {
453		std::mem::take(&mut self.r#mobile_url)
454	}
455	fn get_model(&self) -> &[ModelProperty] {
456		self.r#model.as_slice()
457	}
458	fn take_model(&mut self) -> Vec<ModelProperty> {
459		std::mem::take(&mut self.r#model)
460	}
461	fn get_mpn(&self) -> &[MpnProperty] {
462		self.r#mpn.as_slice()
463	}
464	fn take_mpn(&mut self) -> Vec<MpnProperty> {
465		std::mem::take(&mut self.r#mpn)
466	}
467	fn get_negative_notes(&self) -> &[NegativeNotesProperty] {
468		self.r#negative_notes.as_slice()
469	}
470	fn take_negative_notes(&mut self) -> Vec<NegativeNotesProperty> {
471		std::mem::take(&mut self.r#negative_notes)
472	}
473	fn get_nsn(&self) -> &[NsnProperty] {
474		self.r#nsn.as_slice()
475	}
476	fn take_nsn(&mut self) -> Vec<NsnProperty> {
477		std::mem::take(&mut self.r#nsn)
478	}
479	fn get_offers(&self) -> &[OffersProperty] {
480		self.r#offers.as_slice()
481	}
482	fn take_offers(&mut self) -> Vec<OffersProperty> {
483		std::mem::take(&mut self.r#offers)
484	}
485	fn get_pattern(&self) -> &[PatternProperty] {
486		self.r#pattern.as_slice()
487	}
488	fn take_pattern(&mut self) -> Vec<PatternProperty> {
489		std::mem::take(&mut self.r#pattern)
490	}
491	fn get_positive_notes(&self) -> &[PositiveNotesProperty] {
492		self.r#positive_notes.as_slice()
493	}
494	fn take_positive_notes(&mut self) -> Vec<PositiveNotesProperty> {
495		std::mem::take(&mut self.r#positive_notes)
496	}
497	fn get_product_id(&self) -> &[ProductIdProperty] {
498		self.r#product_id.as_slice()
499	}
500	fn take_product_id(&mut self) -> Vec<ProductIdProperty> {
501		std::mem::take(&mut self.r#product_id)
502	}
503	fn get_production_date(&self) -> &[ProductionDateProperty] {
504		self.r#production_date.as_slice()
505	}
506	fn take_production_date(&mut self) -> Vec<ProductionDateProperty> {
507		std::mem::take(&mut self.r#production_date)
508	}
509	fn get_purchase_date(&self) -> &[PurchaseDateProperty] {
510		self.r#purchase_date.as_slice()
511	}
512	fn take_purchase_date(&mut self) -> Vec<PurchaseDateProperty> {
513		std::mem::take(&mut self.r#purchase_date)
514	}
515	fn get_release_date(&self) -> &[ReleaseDateProperty] {
516		self.r#release_date.as_slice()
517	}
518	fn take_release_date(&mut self) -> Vec<ReleaseDateProperty> {
519		std::mem::take(&mut self.r#release_date)
520	}
521	fn get_review(&self) -> &[ReviewProperty] {
522		self.r#review.as_slice()
523	}
524	fn take_review(&mut self) -> Vec<ReviewProperty> {
525		std::mem::take(&mut self.r#review)
526	}
527	fn get_reviews(&self) -> &[ReviewsProperty] {
528		self.r#reviews.as_slice()
529	}
530	fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
531		std::mem::take(&mut self.r#reviews)
532	}
533	fn get_size(&self) -> &[SizeProperty] {
534		self.r#size.as_slice()
535	}
536	fn take_size(&mut self) -> Vec<SizeProperty> {
537		std::mem::take(&mut self.r#size)
538	}
539	fn get_sku(&self) -> &[SkuProperty] {
540		self.r#sku.as_slice()
541	}
542	fn take_sku(&mut self) -> Vec<SkuProperty> {
543		std::mem::take(&mut self.r#sku)
544	}
545	fn get_slogan(&self) -> &[SloganProperty] {
546		self.r#slogan.as_slice()
547	}
548	fn take_slogan(&mut self) -> Vec<SloganProperty> {
549		std::mem::take(&mut self.r#slogan)
550	}
551	fn get_weight(&self) -> &[WeightProperty] {
552		self.r#weight.as_slice()
553	}
554	fn take_weight(&mut self) -> Vec<WeightProperty> {
555		std::mem::take(&mut self.r#weight)
556	}
557	fn get_width(&self) -> &[WidthProperty] {
558		self.r#width.as_slice()
559	}
560	fn take_width(&mut self) -> Vec<WidthProperty> {
561		std::mem::take(&mut self.r#width)
562	}
563}
564impl ThingTrait for Motorcycle {
565	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
566		self.r#additional_type.as_slice()
567	}
568	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
569		std::mem::take(&mut self.r#additional_type)
570	}
571	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
572		self.r#alternate_name.as_slice()
573	}
574	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
575		std::mem::take(&mut self.r#alternate_name)
576	}
577	fn get_description(&self) -> &[DescriptionProperty] {
578		self.r#description.as_slice()
579	}
580	fn take_description(&mut self) -> Vec<DescriptionProperty> {
581		std::mem::take(&mut self.r#description)
582	}
583	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
584		self.r#disambiguating_description.as_slice()
585	}
586	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
587		std::mem::take(&mut self.r#disambiguating_description)
588	}
589	fn get_identifier(&self) -> &[IdentifierProperty] {
590		self.r#identifier.as_slice()
591	}
592	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
593		std::mem::take(&mut self.r#identifier)
594	}
595	fn get_image(&self) -> &[ImageProperty] {
596		self.r#image.as_slice()
597	}
598	fn take_image(&mut self) -> Vec<ImageProperty> {
599		std::mem::take(&mut self.r#image)
600	}
601	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
602		self.r#main_entity_of_page.as_slice()
603	}
604	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
605		std::mem::take(&mut self.r#main_entity_of_page)
606	}
607	fn get_name(&self) -> &[NameProperty] {
608		self.r#name.as_slice()
609	}
610	fn take_name(&mut self) -> Vec<NameProperty> {
611		std::mem::take(&mut self.r#name)
612	}
613	fn get_potential_action(&self) -> &[PotentialActionProperty] {
614		self.r#potential_action.as_slice()
615	}
616	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
617		std::mem::take(&mut self.r#potential_action)
618	}
619	fn get_same_as(&self) -> &[SameAsProperty] {
620		self.r#same_as.as_slice()
621	}
622	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
623		std::mem::take(&mut self.r#same_as)
624	}
625	fn get_subject_of(&self) -> &[SubjectOfProperty] {
626		self.r#subject_of.as_slice()
627	}
628	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
629		std::mem::take(&mut self.r#subject_of)
630	}
631	fn get_url(&self) -> &[UrlProperty] {
632		self.r#url.as_slice()
633	}
634	fn take_url(&mut self) -> Vec<UrlProperty> {
635		std::mem::take(&mut self.r#url)
636	}
637}
638impl VehicleTrait for Motorcycle {
639	fn get_acceleration_time(&self) -> &[AccelerationTimeProperty] {
640		self.r#acceleration_time.as_slice()
641	}
642	fn take_acceleration_time(&mut self) -> Vec<AccelerationTimeProperty> {
643		std::mem::take(&mut self.r#acceleration_time)
644	}
645	fn get_body_type(&self) -> &[BodyTypeProperty] {
646		self.r#body_type.as_slice()
647	}
648	fn take_body_type(&mut self) -> Vec<BodyTypeProperty> {
649		std::mem::take(&mut self.r#body_type)
650	}
651	fn get_call_sign(&self) -> &[CallSignProperty] {
652		self.r#call_sign.as_slice()
653	}
654	fn take_call_sign(&mut self) -> Vec<CallSignProperty> {
655		std::mem::take(&mut self.r#call_sign)
656	}
657	fn get_cargo_volume(&self) -> &[CargoVolumeProperty] {
658		self.r#cargo_volume.as_slice()
659	}
660	fn take_cargo_volume(&mut self) -> Vec<CargoVolumeProperty> {
661		std::mem::take(&mut self.r#cargo_volume)
662	}
663	fn get_date_vehicle_first_registered(&self) -> &[DateVehicleFirstRegisteredProperty] {
664		self.r#date_vehicle_first_registered.as_slice()
665	}
666	fn take_date_vehicle_first_registered(&mut self) -> Vec<DateVehicleFirstRegisteredProperty> {
667		std::mem::take(&mut self.r#date_vehicle_first_registered)
668	}
669	fn get_drive_wheel_configuration(&self) -> &[DriveWheelConfigurationProperty] {
670		self.r#drive_wheel_configuration.as_slice()
671	}
672	fn take_drive_wheel_configuration(&mut self) -> Vec<DriveWheelConfigurationProperty> {
673		std::mem::take(&mut self.r#drive_wheel_configuration)
674	}
675	fn get_emissions_co_2(&self) -> &[EmissionsCo2Property] {
676		self.r#emissions_co_2.as_slice()
677	}
678	fn take_emissions_co_2(&mut self) -> Vec<EmissionsCo2Property> {
679		std::mem::take(&mut self.r#emissions_co_2)
680	}
681	fn get_fuel_capacity(&self) -> &[FuelCapacityProperty] {
682		self.r#fuel_capacity.as_slice()
683	}
684	fn take_fuel_capacity(&mut self) -> Vec<FuelCapacityProperty> {
685		std::mem::take(&mut self.r#fuel_capacity)
686	}
687	fn get_fuel_consumption(&self) -> &[FuelConsumptionProperty] {
688		self.r#fuel_consumption.as_slice()
689	}
690	fn take_fuel_consumption(&mut self) -> Vec<FuelConsumptionProperty> {
691		std::mem::take(&mut self.r#fuel_consumption)
692	}
693	fn get_fuel_efficiency(&self) -> &[FuelEfficiencyProperty] {
694		self.r#fuel_efficiency.as_slice()
695	}
696	fn take_fuel_efficiency(&mut self) -> Vec<FuelEfficiencyProperty> {
697		std::mem::take(&mut self.r#fuel_efficiency)
698	}
699	fn get_fuel_type(&self) -> &[FuelTypeProperty] {
700		self.r#fuel_type.as_slice()
701	}
702	fn take_fuel_type(&mut self) -> Vec<FuelTypeProperty> {
703		std::mem::take(&mut self.r#fuel_type)
704	}
705	fn get_known_vehicle_damages(&self) -> &[KnownVehicleDamagesProperty] {
706		self.r#known_vehicle_damages.as_slice()
707	}
708	fn take_known_vehicle_damages(&mut self) -> Vec<KnownVehicleDamagesProperty> {
709		std::mem::take(&mut self.r#known_vehicle_damages)
710	}
711	fn get_meets_emission_standard(&self) -> &[MeetsEmissionStandardProperty] {
712		self.r#meets_emission_standard.as_slice()
713	}
714	fn take_meets_emission_standard(&mut self) -> Vec<MeetsEmissionStandardProperty> {
715		std::mem::take(&mut self.r#meets_emission_standard)
716	}
717	fn get_mileage_from_odometer(&self) -> &[MileageFromOdometerProperty] {
718		self.r#mileage_from_odometer.as_slice()
719	}
720	fn take_mileage_from_odometer(&mut self) -> Vec<MileageFromOdometerProperty> {
721		std::mem::take(&mut self.r#mileage_from_odometer)
722	}
723	fn get_model_date(&self) -> &[ModelDateProperty] {
724		self.r#model_date.as_slice()
725	}
726	fn take_model_date(&mut self) -> Vec<ModelDateProperty> {
727		std::mem::take(&mut self.r#model_date)
728	}
729	fn get_number_of_airbags(&self) -> &[NumberOfAirbagsProperty] {
730		self.r#number_of_airbags.as_slice()
731	}
732	fn take_number_of_airbags(&mut self) -> Vec<NumberOfAirbagsProperty> {
733		std::mem::take(&mut self.r#number_of_airbags)
734	}
735	fn get_number_of_axles(&self) -> &[NumberOfAxlesProperty] {
736		self.r#number_of_axles.as_slice()
737	}
738	fn take_number_of_axles(&mut self) -> Vec<NumberOfAxlesProperty> {
739		std::mem::take(&mut self.r#number_of_axles)
740	}
741	fn get_number_of_doors(&self) -> &[NumberOfDoorsProperty] {
742		self.r#number_of_doors.as_slice()
743	}
744	fn take_number_of_doors(&mut self) -> Vec<NumberOfDoorsProperty> {
745		std::mem::take(&mut self.r#number_of_doors)
746	}
747	fn get_number_of_forward_gears(&self) -> &[NumberOfForwardGearsProperty] {
748		self.r#number_of_forward_gears.as_slice()
749	}
750	fn take_number_of_forward_gears(&mut self) -> Vec<NumberOfForwardGearsProperty> {
751		std::mem::take(&mut self.r#number_of_forward_gears)
752	}
753	fn get_number_of_previous_owners(&self) -> &[NumberOfPreviousOwnersProperty] {
754		self.r#number_of_previous_owners.as_slice()
755	}
756	fn take_number_of_previous_owners(&mut self) -> Vec<NumberOfPreviousOwnersProperty> {
757		std::mem::take(&mut self.r#number_of_previous_owners)
758	}
759	fn get_payload(&self) -> &[PayloadProperty] {
760		self.r#payload.as_slice()
761	}
762	fn take_payload(&mut self) -> Vec<PayloadProperty> {
763		std::mem::take(&mut self.r#payload)
764	}
765	fn get_production_date(&self) -> &[ProductionDateProperty] {
766		self.r#production_date.as_slice()
767	}
768	fn take_production_date(&mut self) -> Vec<ProductionDateProperty> {
769		std::mem::take(&mut self.r#production_date)
770	}
771	fn get_purchase_date(&self) -> &[PurchaseDateProperty] {
772		self.r#purchase_date.as_slice()
773	}
774	fn take_purchase_date(&mut self) -> Vec<PurchaseDateProperty> {
775		std::mem::take(&mut self.r#purchase_date)
776	}
777	fn get_seating_capacity(&self) -> &[SeatingCapacityProperty] {
778		self.r#seating_capacity.as_slice()
779	}
780	fn take_seating_capacity(&mut self) -> Vec<SeatingCapacityProperty> {
781		std::mem::take(&mut self.r#seating_capacity)
782	}
783	fn get_speed(&self) -> &[SpeedProperty] {
784		self.r#speed.as_slice()
785	}
786	fn take_speed(&mut self) -> Vec<SpeedProperty> {
787		std::mem::take(&mut self.r#speed)
788	}
789	fn get_steering_position(&self) -> &[SteeringPositionProperty] {
790		self.r#steering_position.as_slice()
791	}
792	fn take_steering_position(&mut self) -> Vec<SteeringPositionProperty> {
793		std::mem::take(&mut self.r#steering_position)
794	}
795	fn get_stupid_property(&self) -> &[StupidPropertyProperty] {
796		self.r#stupid_property.as_slice()
797	}
798	fn take_stupid_property(&mut self) -> Vec<StupidPropertyProperty> {
799		std::mem::take(&mut self.r#stupid_property)
800	}
801	fn get_tongue_weight(&self) -> &[TongueWeightProperty] {
802		self.r#tongue_weight.as_slice()
803	}
804	fn take_tongue_weight(&mut self) -> Vec<TongueWeightProperty> {
805		std::mem::take(&mut self.r#tongue_weight)
806	}
807	fn get_trailer_weight(&self) -> &[TrailerWeightProperty] {
808		self.r#trailer_weight.as_slice()
809	}
810	fn take_trailer_weight(&mut self) -> Vec<TrailerWeightProperty> {
811		std::mem::take(&mut self.r#trailer_weight)
812	}
813	fn get_vehicle_configuration(&self) -> &[VehicleConfigurationProperty] {
814		self.r#vehicle_configuration.as_slice()
815	}
816	fn take_vehicle_configuration(&mut self) -> Vec<VehicleConfigurationProperty> {
817		std::mem::take(&mut self.r#vehicle_configuration)
818	}
819	fn get_vehicle_engine(&self) -> &[VehicleEngineProperty] {
820		self.r#vehicle_engine.as_slice()
821	}
822	fn take_vehicle_engine(&mut self) -> Vec<VehicleEngineProperty> {
823		std::mem::take(&mut self.r#vehicle_engine)
824	}
825	fn get_vehicle_identification_number(&self) -> &[VehicleIdentificationNumberProperty] {
826		self.r#vehicle_identification_number.as_slice()
827	}
828	fn take_vehicle_identification_number(&mut self) -> Vec<VehicleIdentificationNumberProperty> {
829		std::mem::take(&mut self.r#vehicle_identification_number)
830	}
831	fn get_vehicle_interior_color(&self) -> &[VehicleInteriorColorProperty] {
832		self.r#vehicle_interior_color.as_slice()
833	}
834	fn take_vehicle_interior_color(&mut self) -> Vec<VehicleInteriorColorProperty> {
835		std::mem::take(&mut self.r#vehicle_interior_color)
836	}
837	fn get_vehicle_interior_type(&self) -> &[VehicleInteriorTypeProperty] {
838		self.r#vehicle_interior_type.as_slice()
839	}
840	fn take_vehicle_interior_type(&mut self) -> Vec<VehicleInteriorTypeProperty> {
841		std::mem::take(&mut self.r#vehicle_interior_type)
842	}
843	fn get_vehicle_model_date(&self) -> &[VehicleModelDateProperty] {
844		self.r#vehicle_model_date.as_slice()
845	}
846	fn take_vehicle_model_date(&mut self) -> Vec<VehicleModelDateProperty> {
847		std::mem::take(&mut self.r#vehicle_model_date)
848	}
849	fn get_vehicle_seating_capacity(&self) -> &[VehicleSeatingCapacityProperty] {
850		self.r#vehicle_seating_capacity.as_slice()
851	}
852	fn take_vehicle_seating_capacity(&mut self) -> Vec<VehicleSeatingCapacityProperty> {
853		std::mem::take(&mut self.r#vehicle_seating_capacity)
854	}
855	fn get_vehicle_special_usage(&self) -> &[VehicleSpecialUsageProperty] {
856		self.r#vehicle_special_usage.as_slice()
857	}
858	fn take_vehicle_special_usage(&mut self) -> Vec<VehicleSpecialUsageProperty> {
859		std::mem::take(&mut self.r#vehicle_special_usage)
860	}
861	fn get_vehicle_transmission(&self) -> &[VehicleTransmissionProperty] {
862		self.r#vehicle_transmission.as_slice()
863	}
864	fn take_vehicle_transmission(&mut self) -> Vec<VehicleTransmissionProperty> {
865		std::mem::take(&mut self.r#vehicle_transmission)
866	}
867	fn get_weight_total(&self) -> &[WeightTotalProperty] {
868		self.r#weight_total.as_slice()
869	}
870	fn take_weight_total(&mut self) -> Vec<WeightTotalProperty> {
871		std::mem::take(&mut self.r#weight_total)
872	}
873	fn get_wheelbase(&self) -> &[WheelbaseProperty] {
874		self.r#wheelbase.as_slice()
875	}
876	fn take_wheelbase(&mut self) -> Vec<WheelbaseProperty> {
877		std::mem::take(&mut self.r#wheelbase)
878	}
879}
880#[cfg(feature = "serde")]
881mod serde {
882	use std::{fmt, fmt::Formatter};
883
884	use ::serde::{
885		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
886	};
887
888	use super::*;
889	impl Serialize for Motorcycle {
890		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
891		where
892			S: Serializer,
893		{
894			let len: usize = [
895				!Vec::is_empty(&self.r#additional_property) as usize,
896				!Vec::is_empty(&self.r#aggregate_rating) as usize,
897				!Vec::is_empty(&self.r#asin) as usize,
898				!Vec::is_empty(&self.r#audience) as usize,
899				!Vec::is_empty(&self.r#award) as usize,
900				!Vec::is_empty(&self.r#awards) as usize,
901				!Vec::is_empty(&self.r#brand) as usize,
902				!Vec::is_empty(&self.r#category) as usize,
903				!Vec::is_empty(&self.r#color) as usize,
904				!Vec::is_empty(&self.r#country_of_assembly) as usize,
905				!Vec::is_empty(&self.r#country_of_last_processing) as usize,
906				!Vec::is_empty(&self.r#country_of_origin) as usize,
907				!Vec::is_empty(&self.r#depth) as usize,
908				!Vec::is_empty(&self.r#funding) as usize,
909				!Vec::is_empty(&self.r#gtin) as usize,
910				!Vec::is_empty(&self.r#gtin_12) as usize,
911				!Vec::is_empty(&self.r#gtin_13) as usize,
912				!Vec::is_empty(&self.r#gtin_14) as usize,
913				!Vec::is_empty(&self.r#gtin_8) as usize,
914				!Vec::is_empty(&self.r#has_adult_consideration) as usize,
915				!Vec::is_empty(&self.r#has_energy_consumption_details) as usize,
916				!Vec::is_empty(&self.r#has_measurement) as usize,
917				!Vec::is_empty(&self.r#has_merchant_return_policy) as usize,
918				!Vec::is_empty(&self.r#has_product_return_policy) as usize,
919				!Vec::is_empty(&self.r#height) as usize,
920				!Vec::is_empty(&self.r#in_product_group_with_id) as usize,
921				!Vec::is_empty(&self.r#is_accessory_or_spare_part_for) as usize,
922				!Vec::is_empty(&self.r#is_consumable_for) as usize,
923				!Vec::is_empty(&self.r#is_family_friendly) as usize,
924				!Vec::is_empty(&self.r#is_related_to) as usize,
925				!Vec::is_empty(&self.r#is_similar_to) as usize,
926				!Vec::is_empty(&self.r#is_variant_of) as usize,
927				!Vec::is_empty(&self.r#item_condition) as usize,
928				!Vec::is_empty(&self.r#keywords) as usize,
929				!Vec::is_empty(&self.r#logo) as usize,
930				!Vec::is_empty(&self.r#manufacturer) as usize,
931				!Vec::is_empty(&self.r#material) as usize,
932				!Vec::is_empty(&self.r#mobile_url) as usize,
933				!Vec::is_empty(&self.r#model) as usize,
934				!Vec::is_empty(&self.r#mpn) as usize,
935				!Vec::is_empty(&self.r#negative_notes) as usize,
936				!Vec::is_empty(&self.r#nsn) as usize,
937				!Vec::is_empty(&self.r#offers) as usize,
938				!Vec::is_empty(&self.r#pattern) as usize,
939				!Vec::is_empty(&self.r#positive_notes) as usize,
940				!Vec::is_empty(&self.r#product_id) as usize,
941				!Vec::is_empty(&self.r#production_date) as usize,
942				!Vec::is_empty(&self.r#purchase_date) as usize,
943				!Vec::is_empty(&self.r#release_date) as usize,
944				!Vec::is_empty(&self.r#review) as usize,
945				!Vec::is_empty(&self.r#reviews) as usize,
946				!Vec::is_empty(&self.r#size) as usize,
947				!Vec::is_empty(&self.r#sku) as usize,
948				!Vec::is_empty(&self.r#slogan) as usize,
949				!Vec::is_empty(&self.r#weight) as usize,
950				!Vec::is_empty(&self.r#width) as usize,
951				!Vec::is_empty(&self.r#additional_type) as usize,
952				!Vec::is_empty(&self.r#alternate_name) as usize,
953				!Vec::is_empty(&self.r#description) as usize,
954				!Vec::is_empty(&self.r#disambiguating_description) as usize,
955				!Vec::is_empty(&self.r#identifier) as usize,
956				!Vec::is_empty(&self.r#image) as usize,
957				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
958				!Vec::is_empty(&self.r#name) as usize,
959				!Vec::is_empty(&self.r#potential_action) as usize,
960				!Vec::is_empty(&self.r#same_as) as usize,
961				!Vec::is_empty(&self.r#subject_of) as usize,
962				!Vec::is_empty(&self.r#url) as usize,
963				!Vec::is_empty(&self.r#acceleration_time) as usize,
964				!Vec::is_empty(&self.r#body_type) as usize,
965				!Vec::is_empty(&self.r#call_sign) as usize,
966				!Vec::is_empty(&self.r#cargo_volume) as usize,
967				!Vec::is_empty(&self.r#date_vehicle_first_registered) as usize,
968				!Vec::is_empty(&self.r#drive_wheel_configuration) as usize,
969				!Vec::is_empty(&self.r#emissions_co_2) as usize,
970				!Vec::is_empty(&self.r#fuel_capacity) as usize,
971				!Vec::is_empty(&self.r#fuel_consumption) as usize,
972				!Vec::is_empty(&self.r#fuel_efficiency) as usize,
973				!Vec::is_empty(&self.r#fuel_type) as usize,
974				!Vec::is_empty(&self.r#known_vehicle_damages) as usize,
975				!Vec::is_empty(&self.r#meets_emission_standard) as usize,
976				!Vec::is_empty(&self.r#mileage_from_odometer) as usize,
977				!Vec::is_empty(&self.r#model_date) as usize,
978				!Vec::is_empty(&self.r#number_of_airbags) as usize,
979				!Vec::is_empty(&self.r#number_of_axles) as usize,
980				!Vec::is_empty(&self.r#number_of_doors) as usize,
981				!Vec::is_empty(&self.r#number_of_forward_gears) as usize,
982				!Vec::is_empty(&self.r#number_of_previous_owners) as usize,
983				!Vec::is_empty(&self.r#payload) as usize,
984				!Vec::is_empty(&self.r#seating_capacity) as usize,
985				!Vec::is_empty(&self.r#speed) as usize,
986				!Vec::is_empty(&self.r#steering_position) as usize,
987				!Vec::is_empty(&self.r#stupid_property) as usize,
988				!Vec::is_empty(&self.r#tongue_weight) as usize,
989				!Vec::is_empty(&self.r#trailer_weight) as usize,
990				!Vec::is_empty(&self.r#vehicle_configuration) as usize,
991				!Vec::is_empty(&self.r#vehicle_engine) as usize,
992				!Vec::is_empty(&self.r#vehicle_identification_number) as usize,
993				!Vec::is_empty(&self.r#vehicle_interior_color) as usize,
994				!Vec::is_empty(&self.r#vehicle_interior_type) as usize,
995				!Vec::is_empty(&self.r#vehicle_model_date) as usize,
996				!Vec::is_empty(&self.r#vehicle_seating_capacity) as usize,
997				!Vec::is_empty(&self.r#vehicle_special_usage) as usize,
998				!Vec::is_empty(&self.r#vehicle_transmission) as usize,
999				!Vec::is_empty(&self.r#weight_total) as usize,
1000				!Vec::is_empty(&self.r#wheelbase) as usize,
1001			]
1002			.iter()
1003			.sum();
1004			let mut serialize_struct = Serializer::serialize_struct(serializer, "Motorcycle", len)?;
1005			if !Vec::is_empty(&self.r#additional_property) {
1006				serialize_struct.serialize_field("additionalProperty", {
1007					struct SerializeWith<'a>(&'a Vec<AdditionalPropertyProperty>);
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#additional_property)
1019				})?;
1020			} else {
1021				serialize_struct.skip_field("additionalProperty")?;
1022			}
1023			if !Vec::is_empty(&self.r#aggregate_rating) {
1024				serialize_struct.serialize_field("aggregateRating", {
1025					struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
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#aggregate_rating)
1037				})?;
1038			} else {
1039				serialize_struct.skip_field("aggregateRating")?;
1040			}
1041			if !Vec::is_empty(&self.r#asin) {
1042				serialize_struct.serialize_field("asin", {
1043					struct SerializeWith<'a>(&'a Vec<AsinProperty>);
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#asin)
1055				})?;
1056			} else {
1057				serialize_struct.skip_field("asin")?;
1058			}
1059			if !Vec::is_empty(&self.r#audience) {
1060				serialize_struct.serialize_field("audience", {
1061					struct SerializeWith<'a>(&'a Vec<AudienceProperty>);
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#audience)
1073				})?;
1074			} else {
1075				serialize_struct.skip_field("audience")?;
1076			}
1077			if !Vec::is_empty(&self.r#award) {
1078				serialize_struct.serialize_field("award", {
1079					struct SerializeWith<'a>(&'a Vec<AwardProperty>);
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#award)
1091				})?;
1092			} else {
1093				serialize_struct.skip_field("award")?;
1094			}
1095			if !Vec::is_empty(&self.r#awards) {
1096				serialize_struct.serialize_field("awards", {
1097					struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
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#awards)
1109				})?;
1110			} else {
1111				serialize_struct.skip_field("awards")?;
1112			}
1113			if !Vec::is_empty(&self.r#brand) {
1114				serialize_struct.serialize_field("brand", {
1115					struct SerializeWith<'a>(&'a Vec<BrandProperty>);
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#brand)
1127				})?;
1128			} else {
1129				serialize_struct.skip_field("brand")?;
1130			}
1131			if !Vec::is_empty(&self.r#category) {
1132				serialize_struct.serialize_field("category", {
1133					struct SerializeWith<'a>(&'a Vec<CategoryProperty>);
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#category)
1145				})?;
1146			} else {
1147				serialize_struct.skip_field("category")?;
1148			}
1149			if !Vec::is_empty(&self.r#color) {
1150				serialize_struct.serialize_field("color", {
1151					struct SerializeWith<'a>(&'a Vec<ColorProperty>);
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#color)
1163				})?;
1164			} else {
1165				serialize_struct.skip_field("color")?;
1166			}
1167			if !Vec::is_empty(&self.r#country_of_assembly) {
1168				serialize_struct.serialize_field("countryOfAssembly", {
1169					struct SerializeWith<'a>(&'a Vec<CountryOfAssemblyProperty>);
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#country_of_assembly)
1181				})?;
1182			} else {
1183				serialize_struct.skip_field("countryOfAssembly")?;
1184			}
1185			if !Vec::is_empty(&self.r#country_of_last_processing) {
1186				serialize_struct.serialize_field("countryOfLastProcessing", {
1187					struct SerializeWith<'a>(&'a Vec<CountryOfLastProcessingProperty>);
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#country_of_last_processing)
1199				})?;
1200			} else {
1201				serialize_struct.skip_field("countryOfLastProcessing")?;
1202			}
1203			if !Vec::is_empty(&self.r#country_of_origin) {
1204				serialize_struct.serialize_field("countryOfOrigin", {
1205					struct SerializeWith<'a>(&'a Vec<CountryOfOriginProperty>);
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#country_of_origin)
1217				})?;
1218			} else {
1219				serialize_struct.skip_field("countryOfOrigin")?;
1220			}
1221			if !Vec::is_empty(&self.r#depth) {
1222				serialize_struct.serialize_field("depth", {
1223					struct SerializeWith<'a>(&'a Vec<DepthProperty>);
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#depth)
1235				})?;
1236			} else {
1237				serialize_struct.skip_field("depth")?;
1238			}
1239			if !Vec::is_empty(&self.r#funding) {
1240				serialize_struct.serialize_field("funding", {
1241					struct SerializeWith<'a>(&'a Vec<FundingProperty>);
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#funding)
1253				})?;
1254			} else {
1255				serialize_struct.skip_field("funding")?;
1256			}
1257			if !Vec::is_empty(&self.r#gtin) {
1258				serialize_struct.serialize_field("gtin", {
1259					struct SerializeWith<'a>(&'a Vec<GtinProperty>);
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#gtin)
1271				})?;
1272			} else {
1273				serialize_struct.skip_field("gtin")?;
1274			}
1275			if !Vec::is_empty(&self.r#gtin_12) {
1276				serialize_struct.serialize_field("gtin12", {
1277					struct SerializeWith<'a>(&'a Vec<Gtin12Property>);
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#gtin_12)
1289				})?;
1290			} else {
1291				serialize_struct.skip_field("gtin12")?;
1292			}
1293			if !Vec::is_empty(&self.r#gtin_13) {
1294				serialize_struct.serialize_field("gtin13", {
1295					struct SerializeWith<'a>(&'a Vec<Gtin13Property>);
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#gtin_13)
1307				})?;
1308			} else {
1309				serialize_struct.skip_field("gtin13")?;
1310			}
1311			if !Vec::is_empty(&self.r#gtin_14) {
1312				serialize_struct.serialize_field("gtin14", {
1313					struct SerializeWith<'a>(&'a Vec<Gtin14Property>);
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#gtin_14)
1325				})?;
1326			} else {
1327				serialize_struct.skip_field("gtin14")?;
1328			}
1329			if !Vec::is_empty(&self.r#gtin_8) {
1330				serialize_struct.serialize_field("gtin8", {
1331					struct SerializeWith<'a>(&'a Vec<Gtin8Property>);
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#gtin_8)
1343				})?;
1344			} else {
1345				serialize_struct.skip_field("gtin8")?;
1346			}
1347			if !Vec::is_empty(&self.r#has_adult_consideration) {
1348				serialize_struct.serialize_field("hasAdultConsideration", {
1349					struct SerializeWith<'a>(&'a Vec<HasAdultConsiderationProperty>);
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#has_adult_consideration)
1361				})?;
1362			} else {
1363				serialize_struct.skip_field("hasAdultConsideration")?;
1364			}
1365			if !Vec::is_empty(&self.r#has_energy_consumption_details) {
1366				serialize_struct.serialize_field("hasEnergyConsumptionDetails", {
1367					struct SerializeWith<'a>(&'a Vec<HasEnergyConsumptionDetailsProperty>);
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#has_energy_consumption_details)
1379				})?;
1380			} else {
1381				serialize_struct.skip_field("hasEnergyConsumptionDetails")?;
1382			}
1383			if !Vec::is_empty(&self.r#has_measurement) {
1384				serialize_struct.serialize_field("hasMeasurement", {
1385					struct SerializeWith<'a>(&'a Vec<HasMeasurementProperty>);
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#has_measurement)
1397				})?;
1398			} else {
1399				serialize_struct.skip_field("hasMeasurement")?;
1400			}
1401			if !Vec::is_empty(&self.r#has_merchant_return_policy) {
1402				serialize_struct.serialize_field("hasMerchantReturnPolicy", {
1403					struct SerializeWith<'a>(&'a Vec<HasMerchantReturnPolicyProperty>);
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#has_merchant_return_policy)
1415				})?;
1416			} else {
1417				serialize_struct.skip_field("hasMerchantReturnPolicy")?;
1418			}
1419			if !Vec::is_empty(&self.r#has_product_return_policy) {
1420				serialize_struct.serialize_field("hasProductReturnPolicy", {
1421					struct SerializeWith<'a>(&'a Vec<HasProductReturnPolicyProperty>);
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#has_product_return_policy)
1433				})?;
1434			} else {
1435				serialize_struct.skip_field("hasProductReturnPolicy")?;
1436			}
1437			if !Vec::is_empty(&self.r#height) {
1438				serialize_struct.serialize_field("height", {
1439					struct SerializeWith<'a>(&'a Vec<HeightProperty>);
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#height)
1451				})?;
1452			} else {
1453				serialize_struct.skip_field("height")?;
1454			}
1455			if !Vec::is_empty(&self.r#in_product_group_with_id) {
1456				serialize_struct.serialize_field("inProductGroupWithID", {
1457					struct SerializeWith<'a>(&'a Vec<InProductGroupWithIdProperty>);
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#in_product_group_with_id)
1469				})?;
1470			} else {
1471				serialize_struct.skip_field("inProductGroupWithID")?;
1472			}
1473			if !Vec::is_empty(&self.r#is_accessory_or_spare_part_for) {
1474				serialize_struct.serialize_field("isAccessoryOrSparePartFor", {
1475					struct SerializeWith<'a>(&'a Vec<IsAccessoryOrSparePartForProperty>);
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#is_accessory_or_spare_part_for)
1487				})?;
1488			} else {
1489				serialize_struct.skip_field("isAccessoryOrSparePartFor")?;
1490			}
1491			if !Vec::is_empty(&self.r#is_consumable_for) {
1492				serialize_struct.serialize_field("isConsumableFor", {
1493					struct SerializeWith<'a>(&'a Vec<IsConsumableForProperty>);
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#is_consumable_for)
1505				})?;
1506			} else {
1507				serialize_struct.skip_field("isConsumableFor")?;
1508			}
1509			if !Vec::is_empty(&self.r#is_family_friendly) {
1510				serialize_struct.serialize_field("isFamilyFriendly", {
1511					struct SerializeWith<'a>(&'a Vec<IsFamilyFriendlyProperty>);
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#is_family_friendly)
1523				})?;
1524			} else {
1525				serialize_struct.skip_field("isFamilyFriendly")?;
1526			}
1527			if !Vec::is_empty(&self.r#is_related_to) {
1528				serialize_struct.serialize_field("isRelatedTo", {
1529					struct SerializeWith<'a>(&'a Vec<IsRelatedToProperty>);
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#is_related_to)
1541				})?;
1542			} else {
1543				serialize_struct.skip_field("isRelatedTo")?;
1544			}
1545			if !Vec::is_empty(&self.r#is_similar_to) {
1546				serialize_struct.serialize_field("isSimilarTo", {
1547					struct SerializeWith<'a>(&'a Vec<IsSimilarToProperty>);
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#is_similar_to)
1559				})?;
1560			} else {
1561				serialize_struct.skip_field("isSimilarTo")?;
1562			}
1563			if !Vec::is_empty(&self.r#is_variant_of) {
1564				serialize_struct.serialize_field("isVariantOf", {
1565					struct SerializeWith<'a>(&'a Vec<IsVariantOfProperty>);
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#is_variant_of)
1577				})?;
1578			} else {
1579				serialize_struct.skip_field("isVariantOf")?;
1580			}
1581			if !Vec::is_empty(&self.r#item_condition) {
1582				serialize_struct.serialize_field("itemCondition", {
1583					struct SerializeWith<'a>(&'a Vec<ItemConditionProperty>);
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#item_condition)
1595				})?;
1596			} else {
1597				serialize_struct.skip_field("itemCondition")?;
1598			}
1599			if !Vec::is_empty(&self.r#keywords) {
1600				serialize_struct.serialize_field("keywords", {
1601					struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
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#keywords)
1613				})?;
1614			} else {
1615				serialize_struct.skip_field("keywords")?;
1616			}
1617			if !Vec::is_empty(&self.r#logo) {
1618				serialize_struct.serialize_field("logo", {
1619					struct SerializeWith<'a>(&'a Vec<LogoProperty>);
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#logo)
1631				})?;
1632			} else {
1633				serialize_struct.skip_field("logo")?;
1634			}
1635			if !Vec::is_empty(&self.r#manufacturer) {
1636				serialize_struct.serialize_field("manufacturer", {
1637					struct SerializeWith<'a>(&'a Vec<ManufacturerProperty>);
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#manufacturer)
1649				})?;
1650			} else {
1651				serialize_struct.skip_field("manufacturer")?;
1652			}
1653			if !Vec::is_empty(&self.r#material) {
1654				serialize_struct.serialize_field("material", {
1655					struct SerializeWith<'a>(&'a Vec<MaterialProperty>);
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#material)
1667				})?;
1668			} else {
1669				serialize_struct.skip_field("material")?;
1670			}
1671			if !Vec::is_empty(&self.r#mobile_url) {
1672				serialize_struct.serialize_field("mobileUrl", {
1673					struct SerializeWith<'a>(&'a Vec<MobileUrlProperty>);
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#mobile_url)
1685				})?;
1686			} else {
1687				serialize_struct.skip_field("mobileUrl")?;
1688			}
1689			if !Vec::is_empty(&self.r#model) {
1690				serialize_struct.serialize_field("model", {
1691					struct SerializeWith<'a>(&'a Vec<ModelProperty>);
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#model)
1703				})?;
1704			} else {
1705				serialize_struct.skip_field("model")?;
1706			}
1707			if !Vec::is_empty(&self.r#mpn) {
1708				serialize_struct.serialize_field("mpn", {
1709					struct SerializeWith<'a>(&'a Vec<MpnProperty>);
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#mpn)
1721				})?;
1722			} else {
1723				serialize_struct.skip_field("mpn")?;
1724			}
1725			if !Vec::is_empty(&self.r#negative_notes) {
1726				serialize_struct.serialize_field("negativeNotes", {
1727					struct SerializeWith<'a>(&'a Vec<NegativeNotesProperty>);
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#negative_notes)
1739				})?;
1740			} else {
1741				serialize_struct.skip_field("negativeNotes")?;
1742			}
1743			if !Vec::is_empty(&self.r#nsn) {
1744				serialize_struct.serialize_field("nsn", {
1745					struct SerializeWith<'a>(&'a Vec<NsnProperty>);
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#nsn)
1757				})?;
1758			} else {
1759				serialize_struct.skip_field("nsn")?;
1760			}
1761			if !Vec::is_empty(&self.r#offers) {
1762				serialize_struct.serialize_field("offers", {
1763					struct SerializeWith<'a>(&'a Vec<OffersProperty>);
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#offers)
1775				})?;
1776			} else {
1777				serialize_struct.skip_field("offers")?;
1778			}
1779			if !Vec::is_empty(&self.r#pattern) {
1780				serialize_struct.serialize_field("pattern", {
1781					struct SerializeWith<'a>(&'a Vec<PatternProperty>);
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#pattern)
1793				})?;
1794			} else {
1795				serialize_struct.skip_field("pattern")?;
1796			}
1797			if !Vec::is_empty(&self.r#positive_notes) {
1798				serialize_struct.serialize_field("positiveNotes", {
1799					struct SerializeWith<'a>(&'a Vec<PositiveNotesProperty>);
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#positive_notes)
1811				})?;
1812			} else {
1813				serialize_struct.skip_field("positiveNotes")?;
1814			}
1815			if !Vec::is_empty(&self.r#product_id) {
1816				serialize_struct.serialize_field("productID", {
1817					struct SerializeWith<'a>(&'a Vec<ProductIdProperty>);
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#product_id)
1829				})?;
1830			} else {
1831				serialize_struct.skip_field("productID")?;
1832			}
1833			if !Vec::is_empty(&self.r#production_date) {
1834				serialize_struct.serialize_field("productionDate", {
1835					struct SerializeWith<'a>(&'a Vec<ProductionDateProperty>);
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#production_date)
1847				})?;
1848			} else {
1849				serialize_struct.skip_field("productionDate")?;
1850			}
1851			if !Vec::is_empty(&self.r#purchase_date) {
1852				serialize_struct.serialize_field("purchaseDate", {
1853					struct SerializeWith<'a>(&'a Vec<PurchaseDateProperty>);
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#purchase_date)
1865				})?;
1866			} else {
1867				serialize_struct.skip_field("purchaseDate")?;
1868			}
1869			if !Vec::is_empty(&self.r#release_date) {
1870				serialize_struct.serialize_field("releaseDate", {
1871					struct SerializeWith<'a>(&'a Vec<ReleaseDateProperty>);
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#release_date)
1883				})?;
1884			} else {
1885				serialize_struct.skip_field("releaseDate")?;
1886			}
1887			if !Vec::is_empty(&self.r#review) {
1888				serialize_struct.serialize_field("review", {
1889					struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
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#review)
1901				})?;
1902			} else {
1903				serialize_struct.skip_field("review")?;
1904			}
1905			if !Vec::is_empty(&self.r#reviews) {
1906				serialize_struct.serialize_field("reviews", {
1907					struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
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#reviews)
1919				})?;
1920			} else {
1921				serialize_struct.skip_field("reviews")?;
1922			}
1923			if !Vec::is_empty(&self.r#size) {
1924				serialize_struct.serialize_field("size", {
1925					struct SerializeWith<'a>(&'a Vec<SizeProperty>);
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#size)
1937				})?;
1938			} else {
1939				serialize_struct.skip_field("size")?;
1940			}
1941			if !Vec::is_empty(&self.r#sku) {
1942				serialize_struct.serialize_field("sku", {
1943					struct SerializeWith<'a>(&'a Vec<SkuProperty>);
1944					impl<'a> Serialize for SerializeWith<'a> {
1945						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1946						where
1947							S: Serializer,
1948						{
1949							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1950								self.0, serializer,
1951							)
1952						}
1953					}
1954					&SerializeWith(&self.r#sku)
1955				})?;
1956			} else {
1957				serialize_struct.skip_field("sku")?;
1958			}
1959			if !Vec::is_empty(&self.r#slogan) {
1960				serialize_struct.serialize_field("slogan", {
1961					struct SerializeWith<'a>(&'a Vec<SloganProperty>);
1962					impl<'a> Serialize for SerializeWith<'a> {
1963						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1964						where
1965							S: Serializer,
1966						{
1967							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1968								self.0, serializer,
1969							)
1970						}
1971					}
1972					&SerializeWith(&self.r#slogan)
1973				})?;
1974			} else {
1975				serialize_struct.skip_field("slogan")?;
1976			}
1977			if !Vec::is_empty(&self.r#weight) {
1978				serialize_struct.serialize_field("weight", {
1979					struct SerializeWith<'a>(&'a Vec<WeightProperty>);
1980					impl<'a> Serialize for SerializeWith<'a> {
1981						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1982						where
1983							S: Serializer,
1984						{
1985							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1986								self.0, serializer,
1987							)
1988						}
1989					}
1990					&SerializeWith(&self.r#weight)
1991				})?;
1992			} else {
1993				serialize_struct.skip_field("weight")?;
1994			}
1995			if !Vec::is_empty(&self.r#width) {
1996				serialize_struct.serialize_field("width", {
1997					struct SerializeWith<'a>(&'a Vec<WidthProperty>);
1998					impl<'a> Serialize for SerializeWith<'a> {
1999						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2000						where
2001							S: Serializer,
2002						{
2003							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2004								self.0, serializer,
2005							)
2006						}
2007					}
2008					&SerializeWith(&self.r#width)
2009				})?;
2010			} else {
2011				serialize_struct.skip_field("width")?;
2012			}
2013			if !Vec::is_empty(&self.r#additional_type) {
2014				serialize_struct.serialize_field("additionalType", {
2015					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
2016					impl<'a> Serialize for SerializeWith<'a> {
2017						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2018						where
2019							S: Serializer,
2020						{
2021							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2022								self.0, serializer,
2023							)
2024						}
2025					}
2026					&SerializeWith(&self.r#additional_type)
2027				})?;
2028			} else {
2029				serialize_struct.skip_field("additionalType")?;
2030			}
2031			if !Vec::is_empty(&self.r#alternate_name) {
2032				serialize_struct.serialize_field("alternateName", {
2033					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
2034					impl<'a> Serialize for SerializeWith<'a> {
2035						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2036						where
2037							S: Serializer,
2038						{
2039							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2040								self.0, serializer,
2041							)
2042						}
2043					}
2044					&SerializeWith(&self.r#alternate_name)
2045				})?;
2046			} else {
2047				serialize_struct.skip_field("alternateName")?;
2048			}
2049			if !Vec::is_empty(&self.r#description) {
2050				serialize_struct.serialize_field("description", {
2051					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
2052					impl<'a> Serialize for SerializeWith<'a> {
2053						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2054						where
2055							S: Serializer,
2056						{
2057							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2058								self.0, serializer,
2059							)
2060						}
2061					}
2062					&SerializeWith(&self.r#description)
2063				})?;
2064			} else {
2065				serialize_struct.skip_field("description")?;
2066			}
2067			if !Vec::is_empty(&self.r#disambiguating_description) {
2068				serialize_struct.serialize_field("disambiguatingDescription", {
2069					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
2070					impl<'a> Serialize for SerializeWith<'a> {
2071						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2072						where
2073							S: Serializer,
2074						{
2075							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2076								self.0, serializer,
2077							)
2078						}
2079					}
2080					&SerializeWith(&self.r#disambiguating_description)
2081				})?;
2082			} else {
2083				serialize_struct.skip_field("disambiguatingDescription")?;
2084			}
2085			if !Vec::is_empty(&self.r#identifier) {
2086				serialize_struct.serialize_field("identifier", {
2087					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
2088					impl<'a> Serialize for SerializeWith<'a> {
2089						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2090						where
2091							S: Serializer,
2092						{
2093							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2094								self.0, serializer,
2095							)
2096						}
2097					}
2098					&SerializeWith(&self.r#identifier)
2099				})?;
2100			} else {
2101				serialize_struct.skip_field("identifier")?;
2102			}
2103			if !Vec::is_empty(&self.r#image) {
2104				serialize_struct.serialize_field("image", {
2105					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
2106					impl<'a> Serialize for SerializeWith<'a> {
2107						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2108						where
2109							S: Serializer,
2110						{
2111							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2112								self.0, serializer,
2113							)
2114						}
2115					}
2116					&SerializeWith(&self.r#image)
2117				})?;
2118			} else {
2119				serialize_struct.skip_field("image")?;
2120			}
2121			if !Vec::is_empty(&self.r#main_entity_of_page) {
2122				serialize_struct.serialize_field("mainEntityOfPage", {
2123					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
2124					impl<'a> Serialize for SerializeWith<'a> {
2125						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2126						where
2127							S: Serializer,
2128						{
2129							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2130								self.0, serializer,
2131							)
2132						}
2133					}
2134					&SerializeWith(&self.r#main_entity_of_page)
2135				})?;
2136			} else {
2137				serialize_struct.skip_field("mainEntityOfPage")?;
2138			}
2139			if !Vec::is_empty(&self.r#name) {
2140				serialize_struct.serialize_field("name", {
2141					struct SerializeWith<'a>(&'a Vec<NameProperty>);
2142					impl<'a> Serialize for SerializeWith<'a> {
2143						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2144						where
2145							S: Serializer,
2146						{
2147							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2148								self.0, serializer,
2149							)
2150						}
2151					}
2152					&SerializeWith(&self.r#name)
2153				})?;
2154			} else {
2155				serialize_struct.skip_field("name")?;
2156			}
2157			if !Vec::is_empty(&self.r#potential_action) {
2158				serialize_struct.serialize_field("potentialAction", {
2159					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
2160					impl<'a> Serialize for SerializeWith<'a> {
2161						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2162						where
2163							S: Serializer,
2164						{
2165							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2166								self.0, serializer,
2167							)
2168						}
2169					}
2170					&SerializeWith(&self.r#potential_action)
2171				})?;
2172			} else {
2173				serialize_struct.skip_field("potentialAction")?;
2174			}
2175			if !Vec::is_empty(&self.r#same_as) {
2176				serialize_struct.serialize_field("sameAs", {
2177					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
2178					impl<'a> Serialize for SerializeWith<'a> {
2179						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2180						where
2181							S: Serializer,
2182						{
2183							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2184								self.0, serializer,
2185							)
2186						}
2187					}
2188					&SerializeWith(&self.r#same_as)
2189				})?;
2190			} else {
2191				serialize_struct.skip_field("sameAs")?;
2192			}
2193			if !Vec::is_empty(&self.r#subject_of) {
2194				serialize_struct.serialize_field("subjectOf", {
2195					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
2196					impl<'a> Serialize for SerializeWith<'a> {
2197						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2198						where
2199							S: Serializer,
2200						{
2201							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2202								self.0, serializer,
2203							)
2204						}
2205					}
2206					&SerializeWith(&self.r#subject_of)
2207				})?;
2208			} else {
2209				serialize_struct.skip_field("subjectOf")?;
2210			}
2211			if !Vec::is_empty(&self.r#url) {
2212				serialize_struct.serialize_field("url", {
2213					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
2214					impl<'a> Serialize for SerializeWith<'a> {
2215						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2216						where
2217							S: Serializer,
2218						{
2219							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2220								self.0, serializer,
2221							)
2222						}
2223					}
2224					&SerializeWith(&self.r#url)
2225				})?;
2226			} else {
2227				serialize_struct.skip_field("url")?;
2228			}
2229			if !Vec::is_empty(&self.r#acceleration_time) {
2230				serialize_struct.serialize_field("accelerationTime", {
2231					struct SerializeWith<'a>(&'a Vec<AccelerationTimeProperty>);
2232					impl<'a> Serialize for SerializeWith<'a> {
2233						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2234						where
2235							S: Serializer,
2236						{
2237							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2238								self.0, serializer,
2239							)
2240						}
2241					}
2242					&SerializeWith(&self.r#acceleration_time)
2243				})?;
2244			} else {
2245				serialize_struct.skip_field("accelerationTime")?;
2246			}
2247			if !Vec::is_empty(&self.r#body_type) {
2248				serialize_struct.serialize_field("bodyType", {
2249					struct SerializeWith<'a>(&'a Vec<BodyTypeProperty>);
2250					impl<'a> Serialize for SerializeWith<'a> {
2251						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2252						where
2253							S: Serializer,
2254						{
2255							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2256								self.0, serializer,
2257							)
2258						}
2259					}
2260					&SerializeWith(&self.r#body_type)
2261				})?;
2262			} else {
2263				serialize_struct.skip_field("bodyType")?;
2264			}
2265			if !Vec::is_empty(&self.r#call_sign) {
2266				serialize_struct.serialize_field("callSign", {
2267					struct SerializeWith<'a>(&'a Vec<CallSignProperty>);
2268					impl<'a> Serialize for SerializeWith<'a> {
2269						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2270						where
2271							S: Serializer,
2272						{
2273							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2274								self.0, serializer,
2275							)
2276						}
2277					}
2278					&SerializeWith(&self.r#call_sign)
2279				})?;
2280			} else {
2281				serialize_struct.skip_field("callSign")?;
2282			}
2283			if !Vec::is_empty(&self.r#cargo_volume) {
2284				serialize_struct.serialize_field("cargoVolume", {
2285					struct SerializeWith<'a>(&'a Vec<CargoVolumeProperty>);
2286					impl<'a> Serialize for SerializeWith<'a> {
2287						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2288						where
2289							S: Serializer,
2290						{
2291							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2292								self.0, serializer,
2293							)
2294						}
2295					}
2296					&SerializeWith(&self.r#cargo_volume)
2297				})?;
2298			} else {
2299				serialize_struct.skip_field("cargoVolume")?;
2300			}
2301			if !Vec::is_empty(&self.r#date_vehicle_first_registered) {
2302				serialize_struct.serialize_field("dateVehicleFirstRegistered", {
2303					struct SerializeWith<'a>(&'a Vec<DateVehicleFirstRegisteredProperty>);
2304					impl<'a> Serialize for SerializeWith<'a> {
2305						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2306						where
2307							S: Serializer,
2308						{
2309							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2310								self.0, serializer,
2311							)
2312						}
2313					}
2314					&SerializeWith(&self.r#date_vehicle_first_registered)
2315				})?;
2316			} else {
2317				serialize_struct.skip_field("dateVehicleFirstRegistered")?;
2318			}
2319			if !Vec::is_empty(&self.r#drive_wheel_configuration) {
2320				serialize_struct.serialize_field("driveWheelConfiguration", {
2321					struct SerializeWith<'a>(&'a Vec<DriveWheelConfigurationProperty>);
2322					impl<'a> Serialize for SerializeWith<'a> {
2323						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2324						where
2325							S: Serializer,
2326						{
2327							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2328								self.0, serializer,
2329							)
2330						}
2331					}
2332					&SerializeWith(&self.r#drive_wheel_configuration)
2333				})?;
2334			} else {
2335				serialize_struct.skip_field("driveWheelConfiguration")?;
2336			}
2337			if !Vec::is_empty(&self.r#emissions_co_2) {
2338				serialize_struct.serialize_field("emissionsCO2", {
2339					struct SerializeWith<'a>(&'a Vec<EmissionsCo2Property>);
2340					impl<'a> Serialize for SerializeWith<'a> {
2341						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2342						where
2343							S: Serializer,
2344						{
2345							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2346								self.0, serializer,
2347							)
2348						}
2349					}
2350					&SerializeWith(&self.r#emissions_co_2)
2351				})?;
2352			} else {
2353				serialize_struct.skip_field("emissionsCO2")?;
2354			}
2355			if !Vec::is_empty(&self.r#fuel_capacity) {
2356				serialize_struct.serialize_field("fuelCapacity", {
2357					struct SerializeWith<'a>(&'a Vec<FuelCapacityProperty>);
2358					impl<'a> Serialize for SerializeWith<'a> {
2359						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2360						where
2361							S: Serializer,
2362						{
2363							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2364								self.0, serializer,
2365							)
2366						}
2367					}
2368					&SerializeWith(&self.r#fuel_capacity)
2369				})?;
2370			} else {
2371				serialize_struct.skip_field("fuelCapacity")?;
2372			}
2373			if !Vec::is_empty(&self.r#fuel_consumption) {
2374				serialize_struct.serialize_field("fuelConsumption", {
2375					struct SerializeWith<'a>(&'a Vec<FuelConsumptionProperty>);
2376					impl<'a> Serialize for SerializeWith<'a> {
2377						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2378						where
2379							S: Serializer,
2380						{
2381							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2382								self.0, serializer,
2383							)
2384						}
2385					}
2386					&SerializeWith(&self.r#fuel_consumption)
2387				})?;
2388			} else {
2389				serialize_struct.skip_field("fuelConsumption")?;
2390			}
2391			if !Vec::is_empty(&self.r#fuel_efficiency) {
2392				serialize_struct.serialize_field("fuelEfficiency", {
2393					struct SerializeWith<'a>(&'a Vec<FuelEfficiencyProperty>);
2394					impl<'a> Serialize for SerializeWith<'a> {
2395						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2396						where
2397							S: Serializer,
2398						{
2399							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2400								self.0, serializer,
2401							)
2402						}
2403					}
2404					&SerializeWith(&self.r#fuel_efficiency)
2405				})?;
2406			} else {
2407				serialize_struct.skip_field("fuelEfficiency")?;
2408			}
2409			if !Vec::is_empty(&self.r#fuel_type) {
2410				serialize_struct.serialize_field("fuelType", {
2411					struct SerializeWith<'a>(&'a Vec<FuelTypeProperty>);
2412					impl<'a> Serialize for SerializeWith<'a> {
2413						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2414						where
2415							S: Serializer,
2416						{
2417							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2418								self.0, serializer,
2419							)
2420						}
2421					}
2422					&SerializeWith(&self.r#fuel_type)
2423				})?;
2424			} else {
2425				serialize_struct.skip_field("fuelType")?;
2426			}
2427			if !Vec::is_empty(&self.r#known_vehicle_damages) {
2428				serialize_struct.serialize_field("knownVehicleDamages", {
2429					struct SerializeWith<'a>(&'a Vec<KnownVehicleDamagesProperty>);
2430					impl<'a> Serialize for SerializeWith<'a> {
2431						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2432						where
2433							S: Serializer,
2434						{
2435							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2436								self.0, serializer,
2437							)
2438						}
2439					}
2440					&SerializeWith(&self.r#known_vehicle_damages)
2441				})?;
2442			} else {
2443				serialize_struct.skip_field("knownVehicleDamages")?;
2444			}
2445			if !Vec::is_empty(&self.r#meets_emission_standard) {
2446				serialize_struct.serialize_field("meetsEmissionStandard", {
2447					struct SerializeWith<'a>(&'a Vec<MeetsEmissionStandardProperty>);
2448					impl<'a> Serialize for SerializeWith<'a> {
2449						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2450						where
2451							S: Serializer,
2452						{
2453							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2454								self.0, serializer,
2455							)
2456						}
2457					}
2458					&SerializeWith(&self.r#meets_emission_standard)
2459				})?;
2460			} else {
2461				serialize_struct.skip_field("meetsEmissionStandard")?;
2462			}
2463			if !Vec::is_empty(&self.r#mileage_from_odometer) {
2464				serialize_struct.serialize_field("mileageFromOdometer", {
2465					struct SerializeWith<'a>(&'a Vec<MileageFromOdometerProperty>);
2466					impl<'a> Serialize for SerializeWith<'a> {
2467						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2468						where
2469							S: Serializer,
2470						{
2471							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2472								self.0, serializer,
2473							)
2474						}
2475					}
2476					&SerializeWith(&self.r#mileage_from_odometer)
2477				})?;
2478			} else {
2479				serialize_struct.skip_field("mileageFromOdometer")?;
2480			}
2481			if !Vec::is_empty(&self.r#model_date) {
2482				serialize_struct.serialize_field("modelDate", {
2483					struct SerializeWith<'a>(&'a Vec<ModelDateProperty>);
2484					impl<'a> Serialize for SerializeWith<'a> {
2485						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2486						where
2487							S: Serializer,
2488						{
2489							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2490								self.0, serializer,
2491							)
2492						}
2493					}
2494					&SerializeWith(&self.r#model_date)
2495				})?;
2496			} else {
2497				serialize_struct.skip_field("modelDate")?;
2498			}
2499			if !Vec::is_empty(&self.r#number_of_airbags) {
2500				serialize_struct.serialize_field("numberOfAirbags", {
2501					struct SerializeWith<'a>(&'a Vec<NumberOfAirbagsProperty>);
2502					impl<'a> Serialize for SerializeWith<'a> {
2503						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2504						where
2505							S: Serializer,
2506						{
2507							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2508								self.0, serializer,
2509							)
2510						}
2511					}
2512					&SerializeWith(&self.r#number_of_airbags)
2513				})?;
2514			} else {
2515				serialize_struct.skip_field("numberOfAirbags")?;
2516			}
2517			if !Vec::is_empty(&self.r#number_of_axles) {
2518				serialize_struct.serialize_field("numberOfAxles", {
2519					struct SerializeWith<'a>(&'a Vec<NumberOfAxlesProperty>);
2520					impl<'a> Serialize for SerializeWith<'a> {
2521						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2522						where
2523							S: Serializer,
2524						{
2525							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2526								self.0, serializer,
2527							)
2528						}
2529					}
2530					&SerializeWith(&self.r#number_of_axles)
2531				})?;
2532			} else {
2533				serialize_struct.skip_field("numberOfAxles")?;
2534			}
2535			if !Vec::is_empty(&self.r#number_of_doors) {
2536				serialize_struct.serialize_field("numberOfDoors", {
2537					struct SerializeWith<'a>(&'a Vec<NumberOfDoorsProperty>);
2538					impl<'a> Serialize for SerializeWith<'a> {
2539						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2540						where
2541							S: Serializer,
2542						{
2543							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2544								self.0, serializer,
2545							)
2546						}
2547					}
2548					&SerializeWith(&self.r#number_of_doors)
2549				})?;
2550			} else {
2551				serialize_struct.skip_field("numberOfDoors")?;
2552			}
2553			if !Vec::is_empty(&self.r#number_of_forward_gears) {
2554				serialize_struct.serialize_field("numberOfForwardGears", {
2555					struct SerializeWith<'a>(&'a Vec<NumberOfForwardGearsProperty>);
2556					impl<'a> Serialize for SerializeWith<'a> {
2557						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2558						where
2559							S: Serializer,
2560						{
2561							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2562								self.0, serializer,
2563							)
2564						}
2565					}
2566					&SerializeWith(&self.r#number_of_forward_gears)
2567				})?;
2568			} else {
2569				serialize_struct.skip_field("numberOfForwardGears")?;
2570			}
2571			if !Vec::is_empty(&self.r#number_of_previous_owners) {
2572				serialize_struct.serialize_field("numberOfPreviousOwners", {
2573					struct SerializeWith<'a>(&'a Vec<NumberOfPreviousOwnersProperty>);
2574					impl<'a> Serialize for SerializeWith<'a> {
2575						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2576						where
2577							S: Serializer,
2578						{
2579							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2580								self.0, serializer,
2581							)
2582						}
2583					}
2584					&SerializeWith(&self.r#number_of_previous_owners)
2585				})?;
2586			} else {
2587				serialize_struct.skip_field("numberOfPreviousOwners")?;
2588			}
2589			if !Vec::is_empty(&self.r#payload) {
2590				serialize_struct.serialize_field("payload", {
2591					struct SerializeWith<'a>(&'a Vec<PayloadProperty>);
2592					impl<'a> Serialize for SerializeWith<'a> {
2593						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2594						where
2595							S: Serializer,
2596						{
2597							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2598								self.0, serializer,
2599							)
2600						}
2601					}
2602					&SerializeWith(&self.r#payload)
2603				})?;
2604			} else {
2605				serialize_struct.skip_field("payload")?;
2606			}
2607			if !Vec::is_empty(&self.r#seating_capacity) {
2608				serialize_struct.serialize_field("seatingCapacity", {
2609					struct SerializeWith<'a>(&'a Vec<SeatingCapacityProperty>);
2610					impl<'a> Serialize for SerializeWith<'a> {
2611						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2612						where
2613							S: Serializer,
2614						{
2615							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2616								self.0, serializer,
2617							)
2618						}
2619					}
2620					&SerializeWith(&self.r#seating_capacity)
2621				})?;
2622			} else {
2623				serialize_struct.skip_field("seatingCapacity")?;
2624			}
2625			if !Vec::is_empty(&self.r#speed) {
2626				serialize_struct.serialize_field("speed", {
2627					struct SerializeWith<'a>(&'a Vec<SpeedProperty>);
2628					impl<'a> Serialize for SerializeWith<'a> {
2629						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2630						where
2631							S: Serializer,
2632						{
2633							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2634								self.0, serializer,
2635							)
2636						}
2637					}
2638					&SerializeWith(&self.r#speed)
2639				})?;
2640			} else {
2641				serialize_struct.skip_field("speed")?;
2642			}
2643			if !Vec::is_empty(&self.r#steering_position) {
2644				serialize_struct.serialize_field("steeringPosition", {
2645					struct SerializeWith<'a>(&'a Vec<SteeringPositionProperty>);
2646					impl<'a> Serialize for SerializeWith<'a> {
2647						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2648						where
2649							S: Serializer,
2650						{
2651							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2652								self.0, serializer,
2653							)
2654						}
2655					}
2656					&SerializeWith(&self.r#steering_position)
2657				})?;
2658			} else {
2659				serialize_struct.skip_field("steeringPosition")?;
2660			}
2661			if !Vec::is_empty(&self.r#stupid_property) {
2662				serialize_struct.serialize_field("stupidProperty", {
2663					struct SerializeWith<'a>(&'a Vec<StupidPropertyProperty>);
2664					impl<'a> Serialize for SerializeWith<'a> {
2665						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2666						where
2667							S: Serializer,
2668						{
2669							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2670								self.0, serializer,
2671							)
2672						}
2673					}
2674					&SerializeWith(&self.r#stupid_property)
2675				})?;
2676			} else {
2677				serialize_struct.skip_field("stupidProperty")?;
2678			}
2679			if !Vec::is_empty(&self.r#tongue_weight) {
2680				serialize_struct.serialize_field("tongueWeight", {
2681					struct SerializeWith<'a>(&'a Vec<TongueWeightProperty>);
2682					impl<'a> Serialize for SerializeWith<'a> {
2683						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2684						where
2685							S: Serializer,
2686						{
2687							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2688								self.0, serializer,
2689							)
2690						}
2691					}
2692					&SerializeWith(&self.r#tongue_weight)
2693				})?;
2694			} else {
2695				serialize_struct.skip_field("tongueWeight")?;
2696			}
2697			if !Vec::is_empty(&self.r#trailer_weight) {
2698				serialize_struct.serialize_field("trailerWeight", {
2699					struct SerializeWith<'a>(&'a Vec<TrailerWeightProperty>);
2700					impl<'a> Serialize for SerializeWith<'a> {
2701						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2702						where
2703							S: Serializer,
2704						{
2705							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2706								self.0, serializer,
2707							)
2708						}
2709					}
2710					&SerializeWith(&self.r#trailer_weight)
2711				})?;
2712			} else {
2713				serialize_struct.skip_field("trailerWeight")?;
2714			}
2715			if !Vec::is_empty(&self.r#vehicle_configuration) {
2716				serialize_struct.serialize_field("vehicleConfiguration", {
2717					struct SerializeWith<'a>(&'a Vec<VehicleConfigurationProperty>);
2718					impl<'a> Serialize for SerializeWith<'a> {
2719						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2720						where
2721							S: Serializer,
2722						{
2723							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2724								self.0, serializer,
2725							)
2726						}
2727					}
2728					&SerializeWith(&self.r#vehicle_configuration)
2729				})?;
2730			} else {
2731				serialize_struct.skip_field("vehicleConfiguration")?;
2732			}
2733			if !Vec::is_empty(&self.r#vehicle_engine) {
2734				serialize_struct.serialize_field("vehicleEngine", {
2735					struct SerializeWith<'a>(&'a Vec<VehicleEngineProperty>);
2736					impl<'a> Serialize for SerializeWith<'a> {
2737						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2738						where
2739							S: Serializer,
2740						{
2741							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2742								self.0, serializer,
2743							)
2744						}
2745					}
2746					&SerializeWith(&self.r#vehicle_engine)
2747				})?;
2748			} else {
2749				serialize_struct.skip_field("vehicleEngine")?;
2750			}
2751			if !Vec::is_empty(&self.r#vehicle_identification_number) {
2752				serialize_struct.serialize_field("vehicleIdentificationNumber", {
2753					struct SerializeWith<'a>(&'a Vec<VehicleIdentificationNumberProperty>);
2754					impl<'a> Serialize for SerializeWith<'a> {
2755						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2756						where
2757							S: Serializer,
2758						{
2759							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2760								self.0, serializer,
2761							)
2762						}
2763					}
2764					&SerializeWith(&self.r#vehicle_identification_number)
2765				})?;
2766			} else {
2767				serialize_struct.skip_field("vehicleIdentificationNumber")?;
2768			}
2769			if !Vec::is_empty(&self.r#vehicle_interior_color) {
2770				serialize_struct.serialize_field("vehicleInteriorColor", {
2771					struct SerializeWith<'a>(&'a Vec<VehicleInteriorColorProperty>);
2772					impl<'a> Serialize for SerializeWith<'a> {
2773						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2774						where
2775							S: Serializer,
2776						{
2777							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2778								self.0, serializer,
2779							)
2780						}
2781					}
2782					&SerializeWith(&self.r#vehicle_interior_color)
2783				})?;
2784			} else {
2785				serialize_struct.skip_field("vehicleInteriorColor")?;
2786			}
2787			if !Vec::is_empty(&self.r#vehicle_interior_type) {
2788				serialize_struct.serialize_field("vehicleInteriorType", {
2789					struct SerializeWith<'a>(&'a Vec<VehicleInteriorTypeProperty>);
2790					impl<'a> Serialize for SerializeWith<'a> {
2791						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2792						where
2793							S: Serializer,
2794						{
2795							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2796								self.0, serializer,
2797							)
2798						}
2799					}
2800					&SerializeWith(&self.r#vehicle_interior_type)
2801				})?;
2802			} else {
2803				serialize_struct.skip_field("vehicleInteriorType")?;
2804			}
2805			if !Vec::is_empty(&self.r#vehicle_model_date) {
2806				serialize_struct.serialize_field("vehicleModelDate", {
2807					struct SerializeWith<'a>(&'a Vec<VehicleModelDateProperty>);
2808					impl<'a> Serialize for SerializeWith<'a> {
2809						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2810						where
2811							S: Serializer,
2812						{
2813							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2814								self.0, serializer,
2815							)
2816						}
2817					}
2818					&SerializeWith(&self.r#vehicle_model_date)
2819				})?;
2820			} else {
2821				serialize_struct.skip_field("vehicleModelDate")?;
2822			}
2823			if !Vec::is_empty(&self.r#vehicle_seating_capacity) {
2824				serialize_struct.serialize_field("vehicleSeatingCapacity", {
2825					struct SerializeWith<'a>(&'a Vec<VehicleSeatingCapacityProperty>);
2826					impl<'a> Serialize for SerializeWith<'a> {
2827						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2828						where
2829							S: Serializer,
2830						{
2831							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2832								self.0, serializer,
2833							)
2834						}
2835					}
2836					&SerializeWith(&self.r#vehicle_seating_capacity)
2837				})?;
2838			} else {
2839				serialize_struct.skip_field("vehicleSeatingCapacity")?;
2840			}
2841			if !Vec::is_empty(&self.r#vehicle_special_usage) {
2842				serialize_struct.serialize_field("vehicleSpecialUsage", {
2843					struct SerializeWith<'a>(&'a Vec<VehicleSpecialUsageProperty>);
2844					impl<'a> Serialize for SerializeWith<'a> {
2845						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2846						where
2847							S: Serializer,
2848						{
2849							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2850								self.0, serializer,
2851							)
2852						}
2853					}
2854					&SerializeWith(&self.r#vehicle_special_usage)
2855				})?;
2856			} else {
2857				serialize_struct.skip_field("vehicleSpecialUsage")?;
2858			}
2859			if !Vec::is_empty(&self.r#vehicle_transmission) {
2860				serialize_struct.serialize_field("vehicleTransmission", {
2861					struct SerializeWith<'a>(&'a Vec<VehicleTransmissionProperty>);
2862					impl<'a> Serialize for SerializeWith<'a> {
2863						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2864						where
2865							S: Serializer,
2866						{
2867							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2868								self.0, serializer,
2869							)
2870						}
2871					}
2872					&SerializeWith(&self.r#vehicle_transmission)
2873				})?;
2874			} else {
2875				serialize_struct.skip_field("vehicleTransmission")?;
2876			}
2877			if !Vec::is_empty(&self.r#weight_total) {
2878				serialize_struct.serialize_field("weightTotal", {
2879					struct SerializeWith<'a>(&'a Vec<WeightTotalProperty>);
2880					impl<'a> Serialize for SerializeWith<'a> {
2881						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2882						where
2883							S: Serializer,
2884						{
2885							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2886								self.0, serializer,
2887							)
2888						}
2889					}
2890					&SerializeWith(&self.r#weight_total)
2891				})?;
2892			} else {
2893				serialize_struct.skip_field("weightTotal")?;
2894			}
2895			if !Vec::is_empty(&self.r#wheelbase) {
2896				serialize_struct.serialize_field("wheelbase", {
2897					struct SerializeWith<'a>(&'a Vec<WheelbaseProperty>);
2898					impl<'a> Serialize for SerializeWith<'a> {
2899						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2900						where
2901							S: Serializer,
2902						{
2903							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2904								self.0, serializer,
2905							)
2906						}
2907					}
2908					&SerializeWith(&self.r#wheelbase)
2909				})?;
2910			} else {
2911				serialize_struct.skip_field("wheelbase")?;
2912			}
2913			serialize_struct.end()
2914		}
2915	}
2916	impl<'de> Deserialize<'de> for Motorcycle {
2917		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2918		where
2919			D: Deserializer<'de>,
2920		{
2921			enum Field {
2922				AdditionalProperty,
2923				AggregateRating,
2924				Asin,
2925				Audience,
2926				Award,
2927				Awards,
2928				Brand,
2929				Category,
2930				Color,
2931				CountryOfAssembly,
2932				CountryOfLastProcessing,
2933				CountryOfOrigin,
2934				Depth,
2935				Funding,
2936				Gtin,
2937				Gtin12,
2938				Gtin13,
2939				Gtin14,
2940				Gtin8,
2941				HasAdultConsideration,
2942				HasEnergyConsumptionDetails,
2943				HasMeasurement,
2944				HasMerchantReturnPolicy,
2945				HasProductReturnPolicy,
2946				Height,
2947				InProductGroupWithId,
2948				IsAccessoryOrSparePartFor,
2949				IsConsumableFor,
2950				IsFamilyFriendly,
2951				IsRelatedTo,
2952				IsSimilarTo,
2953				IsVariantOf,
2954				ItemCondition,
2955				Keywords,
2956				Logo,
2957				Manufacturer,
2958				Material,
2959				MobileUrl,
2960				Model,
2961				Mpn,
2962				NegativeNotes,
2963				Nsn,
2964				Offers,
2965				Pattern,
2966				PositiveNotes,
2967				ProductId,
2968				ProductionDate,
2969				PurchaseDate,
2970				ReleaseDate,
2971				Review,
2972				Reviews,
2973				Size,
2974				Sku,
2975				Slogan,
2976				Weight,
2977				Width,
2978				AdditionalType,
2979				AlternateName,
2980				Description,
2981				DisambiguatingDescription,
2982				Identifier,
2983				Image,
2984				MainEntityOfPage,
2985				Name,
2986				PotentialAction,
2987				SameAs,
2988				SubjectOf,
2989				Url,
2990				AccelerationTime,
2991				BodyType,
2992				CallSign,
2993				CargoVolume,
2994				DateVehicleFirstRegistered,
2995				DriveWheelConfiguration,
2996				EmissionsCo2,
2997				FuelCapacity,
2998				FuelConsumption,
2999				FuelEfficiency,
3000				FuelType,
3001				KnownVehicleDamages,
3002				MeetsEmissionStandard,
3003				MileageFromOdometer,
3004				ModelDate,
3005				NumberOfAirbags,
3006				NumberOfAxles,
3007				NumberOfDoors,
3008				NumberOfForwardGears,
3009				NumberOfPreviousOwners,
3010				Payload,
3011				SeatingCapacity,
3012				Speed,
3013				SteeringPosition,
3014				StupidProperty,
3015				TongueWeight,
3016				TrailerWeight,
3017				VehicleConfiguration,
3018				VehicleEngine,
3019				VehicleIdentificationNumber,
3020				VehicleInteriorColor,
3021				VehicleInteriorType,
3022				VehicleModelDate,
3023				VehicleSeatingCapacity,
3024				VehicleSpecialUsage,
3025				VehicleTransmission,
3026				WeightTotal,
3027				Wheelbase,
3028				Ignore,
3029			}
3030			struct FieldVisitor;
3031			impl<'de> Visitor<'de> for FieldVisitor {
3032				type Value = Field;
3033				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
3034					formatter.write_str("field identifier")
3035				}
3036				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
3037				where
3038					E: de::Error,
3039				{
3040					match value {
3041						"additionalProperty" => Ok(Field::AdditionalProperty),
3042						"aggregateRating" => Ok(Field::AggregateRating),
3043						"asin" => Ok(Field::Asin),
3044						"audience" => Ok(Field::Audience),
3045						"award" => Ok(Field::Award),
3046						"awards" => Ok(Field::Awards),
3047						"brand" => Ok(Field::Brand),
3048						"category" => Ok(Field::Category),
3049						"color" => Ok(Field::Color),
3050						"countryOfAssembly" => Ok(Field::CountryOfAssembly),
3051						"countryOfLastProcessing" => Ok(Field::CountryOfLastProcessing),
3052						"countryOfOrigin" => Ok(Field::CountryOfOrigin),
3053						"depth" => Ok(Field::Depth),
3054						"funding" => Ok(Field::Funding),
3055						"gtin" => Ok(Field::Gtin),
3056						"gtin12" => Ok(Field::Gtin12),
3057						"gtin13" => Ok(Field::Gtin13),
3058						"gtin14" => Ok(Field::Gtin14),
3059						"gtin8" => Ok(Field::Gtin8),
3060						"hasAdultConsideration" => Ok(Field::HasAdultConsideration),
3061						"hasEnergyConsumptionDetails" => Ok(Field::HasEnergyConsumptionDetails),
3062						"hasMeasurement" => Ok(Field::HasMeasurement),
3063						"hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
3064						"hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
3065						"height" => Ok(Field::Height),
3066						"inProductGroupWithID" => Ok(Field::InProductGroupWithId),
3067						"isAccessoryOrSparePartFor" => Ok(Field::IsAccessoryOrSparePartFor),
3068						"isConsumableFor" => Ok(Field::IsConsumableFor),
3069						"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
3070						"isRelatedTo" => Ok(Field::IsRelatedTo),
3071						"isSimilarTo" => Ok(Field::IsSimilarTo),
3072						"isVariantOf" => Ok(Field::IsVariantOf),
3073						"itemCondition" => Ok(Field::ItemCondition),
3074						"keywords" => Ok(Field::Keywords),
3075						"logo" => Ok(Field::Logo),
3076						"manufacturer" => Ok(Field::Manufacturer),
3077						"material" => Ok(Field::Material),
3078						"mobileUrl" => Ok(Field::MobileUrl),
3079						"model" => Ok(Field::Model),
3080						"mpn" => Ok(Field::Mpn),
3081						"negativeNotes" => Ok(Field::NegativeNotes),
3082						"nsn" => Ok(Field::Nsn),
3083						"offers" => Ok(Field::Offers),
3084						"pattern" => Ok(Field::Pattern),
3085						"positiveNotes" => Ok(Field::PositiveNotes),
3086						"productID" => Ok(Field::ProductId),
3087						"productionDate" => Ok(Field::ProductionDate),
3088						"purchaseDate" => Ok(Field::PurchaseDate),
3089						"releaseDate" => Ok(Field::ReleaseDate),
3090						"review" => Ok(Field::Review),
3091						"reviews" => Ok(Field::Reviews),
3092						"size" => Ok(Field::Size),
3093						"sku" => Ok(Field::Sku),
3094						"slogan" => Ok(Field::Slogan),
3095						"weight" => Ok(Field::Weight),
3096						"width" => Ok(Field::Width),
3097						"additionalType" => Ok(Field::AdditionalType),
3098						"alternateName" => Ok(Field::AlternateName),
3099						"description" => Ok(Field::Description),
3100						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
3101						"identifier" => Ok(Field::Identifier),
3102						"image" => Ok(Field::Image),
3103						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
3104						"name" => Ok(Field::Name),
3105						"potentialAction" => Ok(Field::PotentialAction),
3106						"sameAs" => Ok(Field::SameAs),
3107						"subjectOf" => Ok(Field::SubjectOf),
3108						"url" => Ok(Field::Url),
3109						"accelerationTime" => Ok(Field::AccelerationTime),
3110						"bodyType" => Ok(Field::BodyType),
3111						"callSign" => Ok(Field::CallSign),
3112						"cargoVolume" => Ok(Field::CargoVolume),
3113						"dateVehicleFirstRegistered" => Ok(Field::DateVehicleFirstRegistered),
3114						"driveWheelConfiguration" => Ok(Field::DriveWheelConfiguration),
3115						"emissionsCO2" => Ok(Field::EmissionsCo2),
3116						"fuelCapacity" => Ok(Field::FuelCapacity),
3117						"fuelConsumption" => Ok(Field::FuelConsumption),
3118						"fuelEfficiency" => Ok(Field::FuelEfficiency),
3119						"fuelType" => Ok(Field::FuelType),
3120						"knownVehicleDamages" => Ok(Field::KnownVehicleDamages),
3121						"meetsEmissionStandard" => Ok(Field::MeetsEmissionStandard),
3122						"mileageFromOdometer" => Ok(Field::MileageFromOdometer),
3123						"modelDate" => Ok(Field::ModelDate),
3124						"numberOfAirbags" => Ok(Field::NumberOfAirbags),
3125						"numberOfAxles" => Ok(Field::NumberOfAxles),
3126						"numberOfDoors" => Ok(Field::NumberOfDoors),
3127						"numberOfForwardGears" => Ok(Field::NumberOfForwardGears),
3128						"numberOfPreviousOwners" => Ok(Field::NumberOfPreviousOwners),
3129						"payload" => Ok(Field::Payload),
3130						"seatingCapacity" => Ok(Field::SeatingCapacity),
3131						"speed" => Ok(Field::Speed),
3132						"steeringPosition" => Ok(Field::SteeringPosition),
3133						"stupidProperty" => Ok(Field::StupidProperty),
3134						"tongueWeight" => Ok(Field::TongueWeight),
3135						"trailerWeight" => Ok(Field::TrailerWeight),
3136						"vehicleConfiguration" => Ok(Field::VehicleConfiguration),
3137						"vehicleEngine" => Ok(Field::VehicleEngine),
3138						"vehicleIdentificationNumber" => Ok(Field::VehicleIdentificationNumber),
3139						"vehicleInteriorColor" => Ok(Field::VehicleInteriorColor),
3140						"vehicleInteriorType" => Ok(Field::VehicleInteriorType),
3141						"vehicleModelDate" => Ok(Field::VehicleModelDate),
3142						"vehicleSeatingCapacity" => Ok(Field::VehicleSeatingCapacity),
3143						"vehicleSpecialUsage" => Ok(Field::VehicleSpecialUsage),
3144						"vehicleTransmission" => Ok(Field::VehicleTransmission),
3145						"weightTotal" => Ok(Field::WeightTotal),
3146						"wheelbase" => Ok(Field::Wheelbase),
3147						"id" | "type" => Ok(Field::Ignore),
3148						_ => Err(de::Error::unknown_field(value, FIELDS)),
3149					}
3150				}
3151				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
3152				where
3153					E: de::Error,
3154				{
3155					match value {
3156						b"additionalProperty" => Ok(Field::AdditionalProperty),
3157						b"aggregateRating" => Ok(Field::AggregateRating),
3158						b"asin" => Ok(Field::Asin),
3159						b"audience" => Ok(Field::Audience),
3160						b"award" => Ok(Field::Award),
3161						b"awards" => Ok(Field::Awards),
3162						b"brand" => Ok(Field::Brand),
3163						b"category" => Ok(Field::Category),
3164						b"color" => Ok(Field::Color),
3165						b"countryOfAssembly" => Ok(Field::CountryOfAssembly),
3166						b"countryOfLastProcessing" => Ok(Field::CountryOfLastProcessing),
3167						b"countryOfOrigin" => Ok(Field::CountryOfOrigin),
3168						b"depth" => Ok(Field::Depth),
3169						b"funding" => Ok(Field::Funding),
3170						b"gtin" => Ok(Field::Gtin),
3171						b"gtin12" => Ok(Field::Gtin12),
3172						b"gtin13" => Ok(Field::Gtin13),
3173						b"gtin14" => Ok(Field::Gtin14),
3174						b"gtin8" => Ok(Field::Gtin8),
3175						b"hasAdultConsideration" => Ok(Field::HasAdultConsideration),
3176						b"hasEnergyConsumptionDetails" => Ok(Field::HasEnergyConsumptionDetails),
3177						b"hasMeasurement" => Ok(Field::HasMeasurement),
3178						b"hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
3179						b"hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
3180						b"height" => Ok(Field::Height),
3181						b"inProductGroupWithID" => Ok(Field::InProductGroupWithId),
3182						b"isAccessoryOrSparePartFor" => Ok(Field::IsAccessoryOrSparePartFor),
3183						b"isConsumableFor" => Ok(Field::IsConsumableFor),
3184						b"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
3185						b"isRelatedTo" => Ok(Field::IsRelatedTo),
3186						b"isSimilarTo" => Ok(Field::IsSimilarTo),
3187						b"isVariantOf" => Ok(Field::IsVariantOf),
3188						b"itemCondition" => Ok(Field::ItemCondition),
3189						b"keywords" => Ok(Field::Keywords),
3190						b"logo" => Ok(Field::Logo),
3191						b"manufacturer" => Ok(Field::Manufacturer),
3192						b"material" => Ok(Field::Material),
3193						b"mobileUrl" => Ok(Field::MobileUrl),
3194						b"model" => Ok(Field::Model),
3195						b"mpn" => Ok(Field::Mpn),
3196						b"negativeNotes" => Ok(Field::NegativeNotes),
3197						b"nsn" => Ok(Field::Nsn),
3198						b"offers" => Ok(Field::Offers),
3199						b"pattern" => Ok(Field::Pattern),
3200						b"positiveNotes" => Ok(Field::PositiveNotes),
3201						b"productID" => Ok(Field::ProductId),
3202						b"productionDate" => Ok(Field::ProductionDate),
3203						b"purchaseDate" => Ok(Field::PurchaseDate),
3204						b"releaseDate" => Ok(Field::ReleaseDate),
3205						b"review" => Ok(Field::Review),
3206						b"reviews" => Ok(Field::Reviews),
3207						b"size" => Ok(Field::Size),
3208						b"sku" => Ok(Field::Sku),
3209						b"slogan" => Ok(Field::Slogan),
3210						b"weight" => Ok(Field::Weight),
3211						b"width" => Ok(Field::Width),
3212						b"additionalType" => Ok(Field::AdditionalType),
3213						b"alternateName" => Ok(Field::AlternateName),
3214						b"description" => Ok(Field::Description),
3215						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
3216						b"identifier" => Ok(Field::Identifier),
3217						b"image" => Ok(Field::Image),
3218						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
3219						b"name" => Ok(Field::Name),
3220						b"potentialAction" => Ok(Field::PotentialAction),
3221						b"sameAs" => Ok(Field::SameAs),
3222						b"subjectOf" => Ok(Field::SubjectOf),
3223						b"url" => Ok(Field::Url),
3224						b"accelerationTime" => Ok(Field::AccelerationTime),
3225						b"bodyType" => Ok(Field::BodyType),
3226						b"callSign" => Ok(Field::CallSign),
3227						b"cargoVolume" => Ok(Field::CargoVolume),
3228						b"dateVehicleFirstRegistered" => Ok(Field::DateVehicleFirstRegistered),
3229						b"driveWheelConfiguration" => Ok(Field::DriveWheelConfiguration),
3230						b"emissionsCO2" => Ok(Field::EmissionsCo2),
3231						b"fuelCapacity" => Ok(Field::FuelCapacity),
3232						b"fuelConsumption" => Ok(Field::FuelConsumption),
3233						b"fuelEfficiency" => Ok(Field::FuelEfficiency),
3234						b"fuelType" => Ok(Field::FuelType),
3235						b"knownVehicleDamages" => Ok(Field::KnownVehicleDamages),
3236						b"meetsEmissionStandard" => Ok(Field::MeetsEmissionStandard),
3237						b"mileageFromOdometer" => Ok(Field::MileageFromOdometer),
3238						b"modelDate" => Ok(Field::ModelDate),
3239						b"numberOfAirbags" => Ok(Field::NumberOfAirbags),
3240						b"numberOfAxles" => Ok(Field::NumberOfAxles),
3241						b"numberOfDoors" => Ok(Field::NumberOfDoors),
3242						b"numberOfForwardGears" => Ok(Field::NumberOfForwardGears),
3243						b"numberOfPreviousOwners" => Ok(Field::NumberOfPreviousOwners),
3244						b"payload" => Ok(Field::Payload),
3245						b"seatingCapacity" => Ok(Field::SeatingCapacity),
3246						b"speed" => Ok(Field::Speed),
3247						b"steeringPosition" => Ok(Field::SteeringPosition),
3248						b"stupidProperty" => Ok(Field::StupidProperty),
3249						b"tongueWeight" => Ok(Field::TongueWeight),
3250						b"trailerWeight" => Ok(Field::TrailerWeight),
3251						b"vehicleConfiguration" => Ok(Field::VehicleConfiguration),
3252						b"vehicleEngine" => Ok(Field::VehicleEngine),
3253						b"vehicleIdentificationNumber" => Ok(Field::VehicleIdentificationNumber),
3254						b"vehicleInteriorColor" => Ok(Field::VehicleInteriorColor),
3255						b"vehicleInteriorType" => Ok(Field::VehicleInteriorType),
3256						b"vehicleModelDate" => Ok(Field::VehicleModelDate),
3257						b"vehicleSeatingCapacity" => Ok(Field::VehicleSeatingCapacity),
3258						b"vehicleSpecialUsage" => Ok(Field::VehicleSpecialUsage),
3259						b"vehicleTransmission" => Ok(Field::VehicleTransmission),
3260						b"weightTotal" => Ok(Field::WeightTotal),
3261						b"wheelbase" => Ok(Field::Wheelbase),
3262						b"id" | b"type" => Ok(Field::Ignore),
3263						_ => {
3264							let value = &String::from_utf8_lossy(value);
3265							Err(de::Error::unknown_field(value, FIELDS))
3266						}
3267					}
3268				}
3269			}
3270			impl<'de> Deserialize<'de> for Field {
3271				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3272				where
3273					D: Deserializer<'de>,
3274				{
3275					deserializer.deserialize_identifier(FieldVisitor)
3276				}
3277			}
3278			struct ClassVisitor;
3279			impl<'de> Visitor<'de> for ClassVisitor {
3280				type Value = Motorcycle;
3281				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
3282					formatter.write_str("schema.org schema Motorcycle")
3283				}
3284				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
3285				where
3286					A: de::MapAccess<'de>,
3287				{
3288					let mut r#additional_property_property = None;
3289					let mut r#aggregate_rating_property = None;
3290					let mut r#asin_property = None;
3291					let mut r#audience_property = None;
3292					let mut r#award_property = None;
3293					let mut r#awards_property = None;
3294					let mut r#brand_property = None;
3295					let mut r#category_property = None;
3296					let mut r#color_property = None;
3297					let mut r#country_of_assembly_property = None;
3298					let mut r#country_of_last_processing_property = None;
3299					let mut r#country_of_origin_property = None;
3300					let mut r#depth_property = None;
3301					let mut r#funding_property = None;
3302					let mut r#gtin_property = None;
3303					let mut r#gtin_12_property = None;
3304					let mut r#gtin_13_property = None;
3305					let mut r#gtin_14_property = None;
3306					let mut r#gtin_8_property = None;
3307					let mut r#has_adult_consideration_property = None;
3308					let mut r#has_energy_consumption_details_property = None;
3309					let mut r#has_measurement_property = None;
3310					let mut r#has_merchant_return_policy_property = None;
3311					let mut r#has_product_return_policy_property = None;
3312					let mut r#height_property = None;
3313					let mut r#in_product_group_with_id_property = None;
3314					let mut r#is_accessory_or_spare_part_for_property = None;
3315					let mut r#is_consumable_for_property = None;
3316					let mut r#is_family_friendly_property = None;
3317					let mut r#is_related_to_property = None;
3318					let mut r#is_similar_to_property = None;
3319					let mut r#is_variant_of_property = None;
3320					let mut r#item_condition_property = None;
3321					let mut r#keywords_property = None;
3322					let mut r#logo_property = None;
3323					let mut r#manufacturer_property = None;
3324					let mut r#material_property = None;
3325					let mut r#mobile_url_property = None;
3326					let mut r#model_property = None;
3327					let mut r#mpn_property = None;
3328					let mut r#negative_notes_property = None;
3329					let mut r#nsn_property = None;
3330					let mut r#offers_property = None;
3331					let mut r#pattern_property = None;
3332					let mut r#positive_notes_property = None;
3333					let mut r#product_id_property = None;
3334					let mut r#production_date_property = None;
3335					let mut r#purchase_date_property = None;
3336					let mut r#release_date_property = None;
3337					let mut r#review_property = None;
3338					let mut r#reviews_property = None;
3339					let mut r#size_property = None;
3340					let mut r#sku_property = None;
3341					let mut r#slogan_property = None;
3342					let mut r#weight_property = None;
3343					let mut r#width_property = None;
3344					let mut r#additional_type_property = None;
3345					let mut r#alternate_name_property = None;
3346					let mut r#description_property = None;
3347					let mut r#disambiguating_description_property = None;
3348					let mut r#identifier_property = None;
3349					let mut r#image_property = None;
3350					let mut r#main_entity_of_page_property = None;
3351					let mut r#name_property = None;
3352					let mut r#potential_action_property = None;
3353					let mut r#same_as_property = None;
3354					let mut r#subject_of_property = None;
3355					let mut r#url_property = None;
3356					let mut r#acceleration_time_property = None;
3357					let mut r#body_type_property = None;
3358					let mut r#call_sign_property = None;
3359					let mut r#cargo_volume_property = None;
3360					let mut r#date_vehicle_first_registered_property = None;
3361					let mut r#drive_wheel_configuration_property = None;
3362					let mut r#emissions_co_2_property = None;
3363					let mut r#fuel_capacity_property = None;
3364					let mut r#fuel_consumption_property = None;
3365					let mut r#fuel_efficiency_property = None;
3366					let mut r#fuel_type_property = None;
3367					let mut r#known_vehicle_damages_property = None;
3368					let mut r#meets_emission_standard_property = None;
3369					let mut r#mileage_from_odometer_property = None;
3370					let mut r#model_date_property = None;
3371					let mut r#number_of_airbags_property = None;
3372					let mut r#number_of_axles_property = None;
3373					let mut r#number_of_doors_property = None;
3374					let mut r#number_of_forward_gears_property = None;
3375					let mut r#number_of_previous_owners_property = None;
3376					let mut r#payload_property = None;
3377					let mut r#seating_capacity_property = None;
3378					let mut r#speed_property = None;
3379					let mut r#steering_position_property = None;
3380					let mut r#stupid_property_property = None;
3381					let mut r#tongue_weight_property = None;
3382					let mut r#trailer_weight_property = None;
3383					let mut r#vehicle_configuration_property = None;
3384					let mut r#vehicle_engine_property = None;
3385					let mut r#vehicle_identification_number_property = None;
3386					let mut r#vehicle_interior_color_property = None;
3387					let mut r#vehicle_interior_type_property = None;
3388					let mut r#vehicle_model_date_property = None;
3389					let mut r#vehicle_seating_capacity_property = None;
3390					let mut r#vehicle_special_usage_property = None;
3391					let mut r#vehicle_transmission_property = None;
3392					let mut r#weight_total_property = None;
3393					let mut r#wheelbase_property = None;
3394					while let Some(key) = map.next_key::<Field>()? {
3395						match key {
3396							Field::AdditionalProperty => {
3397								if r#additional_property_property.is_some() {
3398									return Err(<A::Error as de::Error>::duplicate_field(
3399										"additionalProperty",
3400									));
3401								}
3402								r#additional_property_property = Some({
3403									struct DeserializeWith(Vec<AdditionalPropertyProperty>);
3404									impl<'de> Deserialize<'de> for DeserializeWith {
3405										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3406										where
3407											D: Deserializer<'de>,
3408										{
3409											Ok(DeserializeWith(serde_with::As::<
3410												serde_with::OneOrMany<serde_with::Same>,
3411											>::deserialize(deserializer)?))
3412										}
3413									}
3414									match map.next_value::<DeserializeWith>() {
3415										Ok(deserialize_with) => deserialize_with.0,
3416										Err(err) => {
3417											return Err(err);
3418										}
3419									}
3420								});
3421							}
3422							Field::AggregateRating => {
3423								if r#aggregate_rating_property.is_some() {
3424									return Err(<A::Error as de::Error>::duplicate_field(
3425										"aggregateRating",
3426									));
3427								}
3428								r#aggregate_rating_property = Some({
3429									struct DeserializeWith(Vec<AggregateRatingProperty>);
3430									impl<'de> Deserialize<'de> for DeserializeWith {
3431										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3432										where
3433											D: Deserializer<'de>,
3434										{
3435											Ok(DeserializeWith(serde_with::As::<
3436												serde_with::OneOrMany<serde_with::Same>,
3437											>::deserialize(deserializer)?))
3438										}
3439									}
3440									match map.next_value::<DeserializeWith>() {
3441										Ok(deserialize_with) => deserialize_with.0,
3442										Err(err) => {
3443											return Err(err);
3444										}
3445									}
3446								});
3447							}
3448							Field::Asin => {
3449								if r#asin_property.is_some() {
3450									return Err(<A::Error as de::Error>::duplicate_field("asin"));
3451								}
3452								r#asin_property = Some({
3453									struct DeserializeWith(Vec<AsinProperty>);
3454									impl<'de> Deserialize<'de> for DeserializeWith {
3455										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3456										where
3457											D: Deserializer<'de>,
3458										{
3459											Ok(DeserializeWith(serde_with::As::<
3460												serde_with::OneOrMany<serde_with::Same>,
3461											>::deserialize(deserializer)?))
3462										}
3463									}
3464									match map.next_value::<DeserializeWith>() {
3465										Ok(deserialize_with) => deserialize_with.0,
3466										Err(err) => {
3467											return Err(err);
3468										}
3469									}
3470								});
3471							}
3472							Field::Audience => {
3473								if r#audience_property.is_some() {
3474									return Err(<A::Error as de::Error>::duplicate_field(
3475										"audience",
3476									));
3477								}
3478								r#audience_property = Some({
3479									struct DeserializeWith(Vec<AudienceProperty>);
3480									impl<'de> Deserialize<'de> for DeserializeWith {
3481										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3482										where
3483											D: Deserializer<'de>,
3484										{
3485											Ok(DeserializeWith(serde_with::As::<
3486												serde_with::OneOrMany<serde_with::Same>,
3487											>::deserialize(deserializer)?))
3488										}
3489									}
3490									match map.next_value::<DeserializeWith>() {
3491										Ok(deserialize_with) => deserialize_with.0,
3492										Err(err) => {
3493											return Err(err);
3494										}
3495									}
3496								});
3497							}
3498							Field::Award => {
3499								if r#award_property.is_some() {
3500									return Err(<A::Error as de::Error>::duplicate_field("award"));
3501								}
3502								r#award_property = Some({
3503									struct DeserializeWith(Vec<AwardProperty>);
3504									impl<'de> Deserialize<'de> for DeserializeWith {
3505										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3506										where
3507											D: Deserializer<'de>,
3508										{
3509											Ok(DeserializeWith(serde_with::As::<
3510												serde_with::OneOrMany<serde_with::Same>,
3511											>::deserialize(deserializer)?))
3512										}
3513									}
3514									match map.next_value::<DeserializeWith>() {
3515										Ok(deserialize_with) => deserialize_with.0,
3516										Err(err) => {
3517											return Err(err);
3518										}
3519									}
3520								});
3521							}
3522							Field::Awards => {
3523								if r#awards_property.is_some() {
3524									return Err(<A::Error as de::Error>::duplicate_field("awards"));
3525								}
3526								r#awards_property = Some({
3527									struct DeserializeWith(Vec<AwardsProperty>);
3528									impl<'de> Deserialize<'de> for DeserializeWith {
3529										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3530										where
3531											D: Deserializer<'de>,
3532										{
3533											Ok(DeserializeWith(serde_with::As::<
3534												serde_with::OneOrMany<serde_with::Same>,
3535											>::deserialize(deserializer)?))
3536										}
3537									}
3538									match map.next_value::<DeserializeWith>() {
3539										Ok(deserialize_with) => deserialize_with.0,
3540										Err(err) => {
3541											return Err(err);
3542										}
3543									}
3544								});
3545							}
3546							Field::Brand => {
3547								if r#brand_property.is_some() {
3548									return Err(<A::Error as de::Error>::duplicate_field("brand"));
3549								}
3550								r#brand_property = Some({
3551									struct DeserializeWith(Vec<BrandProperty>);
3552									impl<'de> Deserialize<'de> for DeserializeWith {
3553										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3554										where
3555											D: Deserializer<'de>,
3556										{
3557											Ok(DeserializeWith(serde_with::As::<
3558												serde_with::OneOrMany<serde_with::Same>,
3559											>::deserialize(deserializer)?))
3560										}
3561									}
3562									match map.next_value::<DeserializeWith>() {
3563										Ok(deserialize_with) => deserialize_with.0,
3564										Err(err) => {
3565											return Err(err);
3566										}
3567									}
3568								});
3569							}
3570							Field::Category => {
3571								if r#category_property.is_some() {
3572									return Err(<A::Error as de::Error>::duplicate_field(
3573										"category",
3574									));
3575								}
3576								r#category_property = Some({
3577									struct DeserializeWith(Vec<CategoryProperty>);
3578									impl<'de> Deserialize<'de> for DeserializeWith {
3579										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3580										where
3581											D: Deserializer<'de>,
3582										{
3583											Ok(DeserializeWith(serde_with::As::<
3584												serde_with::OneOrMany<serde_with::Same>,
3585											>::deserialize(deserializer)?))
3586										}
3587									}
3588									match map.next_value::<DeserializeWith>() {
3589										Ok(deserialize_with) => deserialize_with.0,
3590										Err(err) => {
3591											return Err(err);
3592										}
3593									}
3594								});
3595							}
3596							Field::Color => {
3597								if r#color_property.is_some() {
3598									return Err(<A::Error as de::Error>::duplicate_field("color"));
3599								}
3600								r#color_property = Some({
3601									struct DeserializeWith(Vec<ColorProperty>);
3602									impl<'de> Deserialize<'de> for DeserializeWith {
3603										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3604										where
3605											D: Deserializer<'de>,
3606										{
3607											Ok(DeserializeWith(serde_with::As::<
3608												serde_with::OneOrMany<serde_with::Same>,
3609											>::deserialize(deserializer)?))
3610										}
3611									}
3612									match map.next_value::<DeserializeWith>() {
3613										Ok(deserialize_with) => deserialize_with.0,
3614										Err(err) => {
3615											return Err(err);
3616										}
3617									}
3618								});
3619							}
3620							Field::CountryOfAssembly => {
3621								if r#country_of_assembly_property.is_some() {
3622									return Err(<A::Error as de::Error>::duplicate_field(
3623										"countryOfAssembly",
3624									));
3625								}
3626								r#country_of_assembly_property = Some({
3627									struct DeserializeWith(Vec<CountryOfAssemblyProperty>);
3628									impl<'de> Deserialize<'de> for DeserializeWith {
3629										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3630										where
3631											D: Deserializer<'de>,
3632										{
3633											Ok(DeserializeWith(serde_with::As::<
3634												serde_with::OneOrMany<serde_with::Same>,
3635											>::deserialize(deserializer)?))
3636										}
3637									}
3638									match map.next_value::<DeserializeWith>() {
3639										Ok(deserialize_with) => deserialize_with.0,
3640										Err(err) => {
3641											return Err(err);
3642										}
3643									}
3644								});
3645							}
3646							Field::CountryOfLastProcessing => {
3647								if r#country_of_last_processing_property.is_some() {
3648									return Err(<A::Error as de::Error>::duplicate_field(
3649										"countryOfLastProcessing",
3650									));
3651								}
3652								r#country_of_last_processing_property = Some({
3653									struct DeserializeWith(Vec<CountryOfLastProcessingProperty>);
3654									impl<'de> Deserialize<'de> for DeserializeWith {
3655										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3656										where
3657											D: Deserializer<'de>,
3658										{
3659											Ok(DeserializeWith(serde_with::As::<
3660												serde_with::OneOrMany<serde_with::Same>,
3661											>::deserialize(deserializer)?))
3662										}
3663									}
3664									match map.next_value::<DeserializeWith>() {
3665										Ok(deserialize_with) => deserialize_with.0,
3666										Err(err) => {
3667											return Err(err);
3668										}
3669									}
3670								});
3671							}
3672							Field::CountryOfOrigin => {
3673								if r#country_of_origin_property.is_some() {
3674									return Err(<A::Error as de::Error>::duplicate_field(
3675										"countryOfOrigin",
3676									));
3677								}
3678								r#country_of_origin_property = Some({
3679									struct DeserializeWith(Vec<CountryOfOriginProperty>);
3680									impl<'de> Deserialize<'de> for DeserializeWith {
3681										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3682										where
3683											D: Deserializer<'de>,
3684										{
3685											Ok(DeserializeWith(serde_with::As::<
3686												serde_with::OneOrMany<serde_with::Same>,
3687											>::deserialize(deserializer)?))
3688										}
3689									}
3690									match map.next_value::<DeserializeWith>() {
3691										Ok(deserialize_with) => deserialize_with.0,
3692										Err(err) => {
3693											return Err(err);
3694										}
3695									}
3696								});
3697							}
3698							Field::Depth => {
3699								if r#depth_property.is_some() {
3700									return Err(<A::Error as de::Error>::duplicate_field("depth"));
3701								}
3702								r#depth_property = Some({
3703									struct DeserializeWith(Vec<DepthProperty>);
3704									impl<'de> Deserialize<'de> for DeserializeWith {
3705										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3706										where
3707											D: Deserializer<'de>,
3708										{
3709											Ok(DeserializeWith(serde_with::As::<
3710												serde_with::OneOrMany<serde_with::Same>,
3711											>::deserialize(deserializer)?))
3712										}
3713									}
3714									match map.next_value::<DeserializeWith>() {
3715										Ok(deserialize_with) => deserialize_with.0,
3716										Err(err) => {
3717											return Err(err);
3718										}
3719									}
3720								});
3721							}
3722							Field::Funding => {
3723								if r#funding_property.is_some() {
3724									return Err(<A::Error as de::Error>::duplicate_field(
3725										"funding",
3726									));
3727								}
3728								r#funding_property = Some({
3729									struct DeserializeWith(Vec<FundingProperty>);
3730									impl<'de> Deserialize<'de> for DeserializeWith {
3731										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3732										where
3733											D: Deserializer<'de>,
3734										{
3735											Ok(DeserializeWith(serde_with::As::<
3736												serde_with::OneOrMany<serde_with::Same>,
3737											>::deserialize(deserializer)?))
3738										}
3739									}
3740									match map.next_value::<DeserializeWith>() {
3741										Ok(deserialize_with) => deserialize_with.0,
3742										Err(err) => {
3743											return Err(err);
3744										}
3745									}
3746								});
3747							}
3748							Field::Gtin => {
3749								if r#gtin_property.is_some() {
3750									return Err(<A::Error as de::Error>::duplicate_field("gtin"));
3751								}
3752								r#gtin_property = Some({
3753									struct DeserializeWith(Vec<GtinProperty>);
3754									impl<'de> Deserialize<'de> for DeserializeWith {
3755										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3756										where
3757											D: Deserializer<'de>,
3758										{
3759											Ok(DeserializeWith(serde_with::As::<
3760												serde_with::OneOrMany<serde_with::Same>,
3761											>::deserialize(deserializer)?))
3762										}
3763									}
3764									match map.next_value::<DeserializeWith>() {
3765										Ok(deserialize_with) => deserialize_with.0,
3766										Err(err) => {
3767											return Err(err);
3768										}
3769									}
3770								});
3771							}
3772							Field::Gtin12 => {
3773								if r#gtin_12_property.is_some() {
3774									return Err(<A::Error as de::Error>::duplicate_field("gtin12"));
3775								}
3776								r#gtin_12_property = Some({
3777									struct DeserializeWith(Vec<Gtin12Property>);
3778									impl<'de> Deserialize<'de> for DeserializeWith {
3779										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3780										where
3781											D: Deserializer<'de>,
3782										{
3783											Ok(DeserializeWith(serde_with::As::<
3784												serde_with::OneOrMany<serde_with::Same>,
3785											>::deserialize(deserializer)?))
3786										}
3787									}
3788									match map.next_value::<DeserializeWith>() {
3789										Ok(deserialize_with) => deserialize_with.0,
3790										Err(err) => {
3791											return Err(err);
3792										}
3793									}
3794								});
3795							}
3796							Field::Gtin13 => {
3797								if r#gtin_13_property.is_some() {
3798									return Err(<A::Error as de::Error>::duplicate_field("gtin13"));
3799								}
3800								r#gtin_13_property = Some({
3801									struct DeserializeWith(Vec<Gtin13Property>);
3802									impl<'de> Deserialize<'de> for DeserializeWith {
3803										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3804										where
3805											D: Deserializer<'de>,
3806										{
3807											Ok(DeserializeWith(serde_with::As::<
3808												serde_with::OneOrMany<serde_with::Same>,
3809											>::deserialize(deserializer)?))
3810										}
3811									}
3812									match map.next_value::<DeserializeWith>() {
3813										Ok(deserialize_with) => deserialize_with.0,
3814										Err(err) => {
3815											return Err(err);
3816										}
3817									}
3818								});
3819							}
3820							Field::Gtin14 => {
3821								if r#gtin_14_property.is_some() {
3822									return Err(<A::Error as de::Error>::duplicate_field("gtin14"));
3823								}
3824								r#gtin_14_property = Some({
3825									struct DeserializeWith(Vec<Gtin14Property>);
3826									impl<'de> Deserialize<'de> for DeserializeWith {
3827										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3828										where
3829											D: Deserializer<'de>,
3830										{
3831											Ok(DeserializeWith(serde_with::As::<
3832												serde_with::OneOrMany<serde_with::Same>,
3833											>::deserialize(deserializer)?))
3834										}
3835									}
3836									match map.next_value::<DeserializeWith>() {
3837										Ok(deserialize_with) => deserialize_with.0,
3838										Err(err) => {
3839											return Err(err);
3840										}
3841									}
3842								});
3843							}
3844							Field::Gtin8 => {
3845								if r#gtin_8_property.is_some() {
3846									return Err(<A::Error as de::Error>::duplicate_field("gtin8"));
3847								}
3848								r#gtin_8_property = Some({
3849									struct DeserializeWith(Vec<Gtin8Property>);
3850									impl<'de> Deserialize<'de> for DeserializeWith {
3851										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3852										where
3853											D: Deserializer<'de>,
3854										{
3855											Ok(DeserializeWith(serde_with::As::<
3856												serde_with::OneOrMany<serde_with::Same>,
3857											>::deserialize(deserializer)?))
3858										}
3859									}
3860									match map.next_value::<DeserializeWith>() {
3861										Ok(deserialize_with) => deserialize_with.0,
3862										Err(err) => {
3863											return Err(err);
3864										}
3865									}
3866								});
3867							}
3868							Field::HasAdultConsideration => {
3869								if r#has_adult_consideration_property.is_some() {
3870									return Err(<A::Error as de::Error>::duplicate_field(
3871										"hasAdultConsideration",
3872									));
3873								}
3874								r#has_adult_consideration_property = Some({
3875									struct DeserializeWith(Vec<HasAdultConsiderationProperty>);
3876									impl<'de> Deserialize<'de> for DeserializeWith {
3877										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3878										where
3879											D: Deserializer<'de>,
3880										{
3881											Ok(DeserializeWith(serde_with::As::<
3882												serde_with::OneOrMany<serde_with::Same>,
3883											>::deserialize(deserializer)?))
3884										}
3885									}
3886									match map.next_value::<DeserializeWith>() {
3887										Ok(deserialize_with) => deserialize_with.0,
3888										Err(err) => {
3889											return Err(err);
3890										}
3891									}
3892								});
3893							}
3894							Field::HasEnergyConsumptionDetails => {
3895								if r#has_energy_consumption_details_property.is_some() {
3896									return Err(<A::Error as de::Error>::duplicate_field(
3897										"hasEnergyConsumptionDetails",
3898									));
3899								}
3900								r#has_energy_consumption_details_property = Some({
3901									struct DeserializeWith(
3902										Vec<HasEnergyConsumptionDetailsProperty>,
3903									);
3904									impl<'de> Deserialize<'de> for DeserializeWith {
3905										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3906										where
3907											D: Deserializer<'de>,
3908										{
3909											Ok(DeserializeWith(serde_with::As::<
3910												serde_with::OneOrMany<serde_with::Same>,
3911											>::deserialize(deserializer)?))
3912										}
3913									}
3914									match map.next_value::<DeserializeWith>() {
3915										Ok(deserialize_with) => deserialize_with.0,
3916										Err(err) => {
3917											return Err(err);
3918										}
3919									}
3920								});
3921							}
3922							Field::HasMeasurement => {
3923								if r#has_measurement_property.is_some() {
3924									return Err(<A::Error as de::Error>::duplicate_field(
3925										"hasMeasurement",
3926									));
3927								}
3928								r#has_measurement_property = Some({
3929									struct DeserializeWith(Vec<HasMeasurementProperty>);
3930									impl<'de> Deserialize<'de> for DeserializeWith {
3931										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3932										where
3933											D: Deserializer<'de>,
3934										{
3935											Ok(DeserializeWith(serde_with::As::<
3936												serde_with::OneOrMany<serde_with::Same>,
3937											>::deserialize(deserializer)?))
3938										}
3939									}
3940									match map.next_value::<DeserializeWith>() {
3941										Ok(deserialize_with) => deserialize_with.0,
3942										Err(err) => {
3943											return Err(err);
3944										}
3945									}
3946								});
3947							}
3948							Field::HasMerchantReturnPolicy => {
3949								if r#has_merchant_return_policy_property.is_some() {
3950									return Err(<A::Error as de::Error>::duplicate_field(
3951										"hasMerchantReturnPolicy",
3952									));
3953								}
3954								r#has_merchant_return_policy_property = Some({
3955									struct DeserializeWith(Vec<HasMerchantReturnPolicyProperty>);
3956									impl<'de> Deserialize<'de> for DeserializeWith {
3957										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3958										where
3959											D: Deserializer<'de>,
3960										{
3961											Ok(DeserializeWith(serde_with::As::<
3962												serde_with::OneOrMany<serde_with::Same>,
3963											>::deserialize(deserializer)?))
3964										}
3965									}
3966									match map.next_value::<DeserializeWith>() {
3967										Ok(deserialize_with) => deserialize_with.0,
3968										Err(err) => {
3969											return Err(err);
3970										}
3971									}
3972								});
3973							}
3974							Field::HasProductReturnPolicy => {
3975								if r#has_product_return_policy_property.is_some() {
3976									return Err(<A::Error as de::Error>::duplicate_field(
3977										"hasProductReturnPolicy",
3978									));
3979								}
3980								r#has_product_return_policy_property = Some({
3981									struct DeserializeWith(Vec<HasProductReturnPolicyProperty>);
3982									impl<'de> Deserialize<'de> for DeserializeWith {
3983										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3984										where
3985											D: Deserializer<'de>,
3986										{
3987											Ok(DeserializeWith(serde_with::As::<
3988												serde_with::OneOrMany<serde_with::Same>,
3989											>::deserialize(deserializer)?))
3990										}
3991									}
3992									match map.next_value::<DeserializeWith>() {
3993										Ok(deserialize_with) => deserialize_with.0,
3994										Err(err) => {
3995											return Err(err);
3996										}
3997									}
3998								});
3999							}
4000							Field::Height => {
4001								if r#height_property.is_some() {
4002									return Err(<A::Error as de::Error>::duplicate_field("height"));
4003								}
4004								r#height_property = Some({
4005									struct DeserializeWith(Vec<HeightProperty>);
4006									impl<'de> Deserialize<'de> for DeserializeWith {
4007										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4008										where
4009											D: Deserializer<'de>,
4010										{
4011											Ok(DeserializeWith(serde_with::As::<
4012												serde_with::OneOrMany<serde_with::Same>,
4013											>::deserialize(deserializer)?))
4014										}
4015									}
4016									match map.next_value::<DeserializeWith>() {
4017										Ok(deserialize_with) => deserialize_with.0,
4018										Err(err) => {
4019											return Err(err);
4020										}
4021									}
4022								});
4023							}
4024							Field::InProductGroupWithId => {
4025								if r#in_product_group_with_id_property.is_some() {
4026									return Err(<A::Error as de::Error>::duplicate_field(
4027										"inProductGroupWithID",
4028									));
4029								}
4030								r#in_product_group_with_id_property = Some({
4031									struct DeserializeWith(Vec<InProductGroupWithIdProperty>);
4032									impl<'de> Deserialize<'de> for DeserializeWith {
4033										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4034										where
4035											D: Deserializer<'de>,
4036										{
4037											Ok(DeserializeWith(serde_with::As::<
4038												serde_with::OneOrMany<serde_with::Same>,
4039											>::deserialize(deserializer)?))
4040										}
4041									}
4042									match map.next_value::<DeserializeWith>() {
4043										Ok(deserialize_with) => deserialize_with.0,
4044										Err(err) => {
4045											return Err(err);
4046										}
4047									}
4048								});
4049							}
4050							Field::IsAccessoryOrSparePartFor => {
4051								if r#is_accessory_or_spare_part_for_property.is_some() {
4052									return Err(<A::Error as de::Error>::duplicate_field(
4053										"isAccessoryOrSparePartFor",
4054									));
4055								}
4056								r#is_accessory_or_spare_part_for_property = Some({
4057									struct DeserializeWith(Vec<IsAccessoryOrSparePartForProperty>);
4058									impl<'de> Deserialize<'de> for DeserializeWith {
4059										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4060										where
4061											D: Deserializer<'de>,
4062										{
4063											Ok(DeserializeWith(serde_with::As::<
4064												serde_with::OneOrMany<serde_with::Same>,
4065											>::deserialize(deserializer)?))
4066										}
4067									}
4068									match map.next_value::<DeserializeWith>() {
4069										Ok(deserialize_with) => deserialize_with.0,
4070										Err(err) => {
4071											return Err(err);
4072										}
4073									}
4074								});
4075							}
4076							Field::IsConsumableFor => {
4077								if r#is_consumable_for_property.is_some() {
4078									return Err(<A::Error as de::Error>::duplicate_field(
4079										"isConsumableFor",
4080									));
4081								}
4082								r#is_consumable_for_property = Some({
4083									struct DeserializeWith(Vec<IsConsumableForProperty>);
4084									impl<'de> Deserialize<'de> for DeserializeWith {
4085										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4086										where
4087											D: Deserializer<'de>,
4088										{
4089											Ok(DeserializeWith(serde_with::As::<
4090												serde_with::OneOrMany<serde_with::Same>,
4091											>::deserialize(deserializer)?))
4092										}
4093									}
4094									match map.next_value::<DeserializeWith>() {
4095										Ok(deserialize_with) => deserialize_with.0,
4096										Err(err) => {
4097											return Err(err);
4098										}
4099									}
4100								});
4101							}
4102							Field::IsFamilyFriendly => {
4103								if r#is_family_friendly_property.is_some() {
4104									return Err(<A::Error as de::Error>::duplicate_field(
4105										"isFamilyFriendly",
4106									));
4107								}
4108								r#is_family_friendly_property = Some({
4109									struct DeserializeWith(Vec<IsFamilyFriendlyProperty>);
4110									impl<'de> Deserialize<'de> for DeserializeWith {
4111										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4112										where
4113											D: Deserializer<'de>,
4114										{
4115											Ok(DeserializeWith(serde_with::As::<
4116												serde_with::OneOrMany<serde_with::Same>,
4117											>::deserialize(deserializer)?))
4118										}
4119									}
4120									match map.next_value::<DeserializeWith>() {
4121										Ok(deserialize_with) => deserialize_with.0,
4122										Err(err) => {
4123											return Err(err);
4124										}
4125									}
4126								});
4127							}
4128							Field::IsRelatedTo => {
4129								if r#is_related_to_property.is_some() {
4130									return Err(<A::Error as de::Error>::duplicate_field(
4131										"isRelatedTo",
4132									));
4133								}
4134								r#is_related_to_property = Some({
4135									struct DeserializeWith(Vec<IsRelatedToProperty>);
4136									impl<'de> Deserialize<'de> for DeserializeWith {
4137										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4138										where
4139											D: Deserializer<'de>,
4140										{
4141											Ok(DeserializeWith(serde_with::As::<
4142												serde_with::OneOrMany<serde_with::Same>,
4143											>::deserialize(deserializer)?))
4144										}
4145									}
4146									match map.next_value::<DeserializeWith>() {
4147										Ok(deserialize_with) => deserialize_with.0,
4148										Err(err) => {
4149											return Err(err);
4150										}
4151									}
4152								});
4153							}
4154							Field::IsSimilarTo => {
4155								if r#is_similar_to_property.is_some() {
4156									return Err(<A::Error as de::Error>::duplicate_field(
4157										"isSimilarTo",
4158									));
4159								}
4160								r#is_similar_to_property = Some({
4161									struct DeserializeWith(Vec<IsSimilarToProperty>);
4162									impl<'de> Deserialize<'de> for DeserializeWith {
4163										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4164										where
4165											D: Deserializer<'de>,
4166										{
4167											Ok(DeserializeWith(serde_with::As::<
4168												serde_with::OneOrMany<serde_with::Same>,
4169											>::deserialize(deserializer)?))
4170										}
4171									}
4172									match map.next_value::<DeserializeWith>() {
4173										Ok(deserialize_with) => deserialize_with.0,
4174										Err(err) => {
4175											return Err(err);
4176										}
4177									}
4178								});
4179							}
4180							Field::IsVariantOf => {
4181								if r#is_variant_of_property.is_some() {
4182									return Err(<A::Error as de::Error>::duplicate_field(
4183										"isVariantOf",
4184									));
4185								}
4186								r#is_variant_of_property = Some({
4187									struct DeserializeWith(Vec<IsVariantOfProperty>);
4188									impl<'de> Deserialize<'de> for DeserializeWith {
4189										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4190										where
4191											D: Deserializer<'de>,
4192										{
4193											Ok(DeserializeWith(serde_with::As::<
4194												serde_with::OneOrMany<serde_with::Same>,
4195											>::deserialize(deserializer)?))
4196										}
4197									}
4198									match map.next_value::<DeserializeWith>() {
4199										Ok(deserialize_with) => deserialize_with.0,
4200										Err(err) => {
4201											return Err(err);
4202										}
4203									}
4204								});
4205							}
4206							Field::ItemCondition => {
4207								if r#item_condition_property.is_some() {
4208									return Err(<A::Error as de::Error>::duplicate_field(
4209										"itemCondition",
4210									));
4211								}
4212								r#item_condition_property = Some({
4213									struct DeserializeWith(Vec<ItemConditionProperty>);
4214									impl<'de> Deserialize<'de> for DeserializeWith {
4215										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4216										where
4217											D: Deserializer<'de>,
4218										{
4219											Ok(DeserializeWith(serde_with::As::<
4220												serde_with::OneOrMany<serde_with::Same>,
4221											>::deserialize(deserializer)?))
4222										}
4223									}
4224									match map.next_value::<DeserializeWith>() {
4225										Ok(deserialize_with) => deserialize_with.0,
4226										Err(err) => {
4227											return Err(err);
4228										}
4229									}
4230								});
4231							}
4232							Field::Keywords => {
4233								if r#keywords_property.is_some() {
4234									return Err(<A::Error as de::Error>::duplicate_field(
4235										"keywords",
4236									));
4237								}
4238								r#keywords_property = Some({
4239									struct DeserializeWith(Vec<KeywordsProperty>);
4240									impl<'de> Deserialize<'de> for DeserializeWith {
4241										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4242										where
4243											D: Deserializer<'de>,
4244										{
4245											Ok(DeserializeWith(serde_with::As::<
4246												serde_with::OneOrMany<serde_with::Same>,
4247											>::deserialize(deserializer)?))
4248										}
4249									}
4250									match map.next_value::<DeserializeWith>() {
4251										Ok(deserialize_with) => deserialize_with.0,
4252										Err(err) => {
4253											return Err(err);
4254										}
4255									}
4256								});
4257							}
4258							Field::Logo => {
4259								if r#logo_property.is_some() {
4260									return Err(<A::Error as de::Error>::duplicate_field("logo"));
4261								}
4262								r#logo_property = Some({
4263									struct DeserializeWith(Vec<LogoProperty>);
4264									impl<'de> Deserialize<'de> for DeserializeWith {
4265										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4266										where
4267											D: Deserializer<'de>,
4268										{
4269											Ok(DeserializeWith(serde_with::As::<
4270												serde_with::OneOrMany<serde_with::Same>,
4271											>::deserialize(deserializer)?))
4272										}
4273									}
4274									match map.next_value::<DeserializeWith>() {
4275										Ok(deserialize_with) => deserialize_with.0,
4276										Err(err) => {
4277											return Err(err);
4278										}
4279									}
4280								});
4281							}
4282							Field::Manufacturer => {
4283								if r#manufacturer_property.is_some() {
4284									return Err(<A::Error as de::Error>::duplicate_field(
4285										"manufacturer",
4286									));
4287								}
4288								r#manufacturer_property = Some({
4289									struct DeserializeWith(Vec<ManufacturerProperty>);
4290									impl<'de> Deserialize<'de> for DeserializeWith {
4291										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4292										where
4293											D: Deserializer<'de>,
4294										{
4295											Ok(DeserializeWith(serde_with::As::<
4296												serde_with::OneOrMany<serde_with::Same>,
4297											>::deserialize(deserializer)?))
4298										}
4299									}
4300									match map.next_value::<DeserializeWith>() {
4301										Ok(deserialize_with) => deserialize_with.0,
4302										Err(err) => {
4303											return Err(err);
4304										}
4305									}
4306								});
4307							}
4308							Field::Material => {
4309								if r#material_property.is_some() {
4310									return Err(<A::Error as de::Error>::duplicate_field(
4311										"material",
4312									));
4313								}
4314								r#material_property = Some({
4315									struct DeserializeWith(Vec<MaterialProperty>);
4316									impl<'de> Deserialize<'de> for DeserializeWith {
4317										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4318										where
4319											D: Deserializer<'de>,
4320										{
4321											Ok(DeserializeWith(serde_with::As::<
4322												serde_with::OneOrMany<serde_with::Same>,
4323											>::deserialize(deserializer)?))
4324										}
4325									}
4326									match map.next_value::<DeserializeWith>() {
4327										Ok(deserialize_with) => deserialize_with.0,
4328										Err(err) => {
4329											return Err(err);
4330										}
4331									}
4332								});
4333							}
4334							Field::MobileUrl => {
4335								if r#mobile_url_property.is_some() {
4336									return Err(<A::Error as de::Error>::duplicate_field(
4337										"mobileUrl",
4338									));
4339								}
4340								r#mobile_url_property = Some({
4341									struct DeserializeWith(Vec<MobileUrlProperty>);
4342									impl<'de> Deserialize<'de> for DeserializeWith {
4343										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4344										where
4345											D: Deserializer<'de>,
4346										{
4347											Ok(DeserializeWith(serde_with::As::<
4348												serde_with::OneOrMany<serde_with::Same>,
4349											>::deserialize(deserializer)?))
4350										}
4351									}
4352									match map.next_value::<DeserializeWith>() {
4353										Ok(deserialize_with) => deserialize_with.0,
4354										Err(err) => {
4355											return Err(err);
4356										}
4357									}
4358								});
4359							}
4360							Field::Model => {
4361								if r#model_property.is_some() {
4362									return Err(<A::Error as de::Error>::duplicate_field("model"));
4363								}
4364								r#model_property = Some({
4365									struct DeserializeWith(Vec<ModelProperty>);
4366									impl<'de> Deserialize<'de> for DeserializeWith {
4367										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4368										where
4369											D: Deserializer<'de>,
4370										{
4371											Ok(DeserializeWith(serde_with::As::<
4372												serde_with::OneOrMany<serde_with::Same>,
4373											>::deserialize(deserializer)?))
4374										}
4375									}
4376									match map.next_value::<DeserializeWith>() {
4377										Ok(deserialize_with) => deserialize_with.0,
4378										Err(err) => {
4379											return Err(err);
4380										}
4381									}
4382								});
4383							}
4384							Field::Mpn => {
4385								if r#mpn_property.is_some() {
4386									return Err(<A::Error as de::Error>::duplicate_field("mpn"));
4387								}
4388								r#mpn_property = Some({
4389									struct DeserializeWith(Vec<MpnProperty>);
4390									impl<'de> Deserialize<'de> for DeserializeWith {
4391										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4392										where
4393											D: Deserializer<'de>,
4394										{
4395											Ok(DeserializeWith(serde_with::As::<
4396												serde_with::OneOrMany<serde_with::Same>,
4397											>::deserialize(deserializer)?))
4398										}
4399									}
4400									match map.next_value::<DeserializeWith>() {
4401										Ok(deserialize_with) => deserialize_with.0,
4402										Err(err) => {
4403											return Err(err);
4404										}
4405									}
4406								});
4407							}
4408							Field::NegativeNotes => {
4409								if r#negative_notes_property.is_some() {
4410									return Err(<A::Error as de::Error>::duplicate_field(
4411										"negativeNotes",
4412									));
4413								}
4414								r#negative_notes_property = Some({
4415									struct DeserializeWith(Vec<NegativeNotesProperty>);
4416									impl<'de> Deserialize<'de> for DeserializeWith {
4417										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4418										where
4419											D: Deserializer<'de>,
4420										{
4421											Ok(DeserializeWith(serde_with::As::<
4422												serde_with::OneOrMany<serde_with::Same>,
4423											>::deserialize(deserializer)?))
4424										}
4425									}
4426									match map.next_value::<DeserializeWith>() {
4427										Ok(deserialize_with) => deserialize_with.0,
4428										Err(err) => {
4429											return Err(err);
4430										}
4431									}
4432								});
4433							}
4434							Field::Nsn => {
4435								if r#nsn_property.is_some() {
4436									return Err(<A::Error as de::Error>::duplicate_field("nsn"));
4437								}
4438								r#nsn_property = Some({
4439									struct DeserializeWith(Vec<NsnProperty>);
4440									impl<'de> Deserialize<'de> for DeserializeWith {
4441										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4442										where
4443											D: Deserializer<'de>,
4444										{
4445											Ok(DeserializeWith(serde_with::As::<
4446												serde_with::OneOrMany<serde_with::Same>,
4447											>::deserialize(deserializer)?))
4448										}
4449									}
4450									match map.next_value::<DeserializeWith>() {
4451										Ok(deserialize_with) => deserialize_with.0,
4452										Err(err) => {
4453											return Err(err);
4454										}
4455									}
4456								});
4457							}
4458							Field::Offers => {
4459								if r#offers_property.is_some() {
4460									return Err(<A::Error as de::Error>::duplicate_field("offers"));
4461								}
4462								r#offers_property = Some({
4463									struct DeserializeWith(Vec<OffersProperty>);
4464									impl<'de> Deserialize<'de> for DeserializeWith {
4465										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4466										where
4467											D: Deserializer<'de>,
4468										{
4469											Ok(DeserializeWith(serde_with::As::<
4470												serde_with::OneOrMany<serde_with::Same>,
4471											>::deserialize(deserializer)?))
4472										}
4473									}
4474									match map.next_value::<DeserializeWith>() {
4475										Ok(deserialize_with) => deserialize_with.0,
4476										Err(err) => {
4477											return Err(err);
4478										}
4479									}
4480								});
4481							}
4482							Field::Pattern => {
4483								if r#pattern_property.is_some() {
4484									return Err(<A::Error as de::Error>::duplicate_field(
4485										"pattern",
4486									));
4487								}
4488								r#pattern_property = Some({
4489									struct DeserializeWith(Vec<PatternProperty>);
4490									impl<'de> Deserialize<'de> for DeserializeWith {
4491										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4492										where
4493											D: Deserializer<'de>,
4494										{
4495											Ok(DeserializeWith(serde_with::As::<
4496												serde_with::OneOrMany<serde_with::Same>,
4497											>::deserialize(deserializer)?))
4498										}
4499									}
4500									match map.next_value::<DeserializeWith>() {
4501										Ok(deserialize_with) => deserialize_with.0,
4502										Err(err) => {
4503											return Err(err);
4504										}
4505									}
4506								});
4507							}
4508							Field::PositiveNotes => {
4509								if r#positive_notes_property.is_some() {
4510									return Err(<A::Error as de::Error>::duplicate_field(
4511										"positiveNotes",
4512									));
4513								}
4514								r#positive_notes_property = Some({
4515									struct DeserializeWith(Vec<PositiveNotesProperty>);
4516									impl<'de> Deserialize<'de> for DeserializeWith {
4517										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4518										where
4519											D: Deserializer<'de>,
4520										{
4521											Ok(DeserializeWith(serde_with::As::<
4522												serde_with::OneOrMany<serde_with::Same>,
4523											>::deserialize(deserializer)?))
4524										}
4525									}
4526									match map.next_value::<DeserializeWith>() {
4527										Ok(deserialize_with) => deserialize_with.0,
4528										Err(err) => {
4529											return Err(err);
4530										}
4531									}
4532								});
4533							}
4534							Field::ProductId => {
4535								if r#product_id_property.is_some() {
4536									return Err(<A::Error as de::Error>::duplicate_field(
4537										"productID",
4538									));
4539								}
4540								r#product_id_property = Some({
4541									struct DeserializeWith(Vec<ProductIdProperty>);
4542									impl<'de> Deserialize<'de> for DeserializeWith {
4543										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4544										where
4545											D: Deserializer<'de>,
4546										{
4547											Ok(DeserializeWith(serde_with::As::<
4548												serde_with::OneOrMany<serde_with::Same>,
4549											>::deserialize(deserializer)?))
4550										}
4551									}
4552									match map.next_value::<DeserializeWith>() {
4553										Ok(deserialize_with) => deserialize_with.0,
4554										Err(err) => {
4555											return Err(err);
4556										}
4557									}
4558								});
4559							}
4560							Field::ProductionDate => {
4561								if r#production_date_property.is_some() {
4562									return Err(<A::Error as de::Error>::duplicate_field(
4563										"productionDate",
4564									));
4565								}
4566								r#production_date_property = Some({
4567									struct DeserializeWith(Vec<ProductionDateProperty>);
4568									impl<'de> Deserialize<'de> for DeserializeWith {
4569										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4570										where
4571											D: Deserializer<'de>,
4572										{
4573											Ok(DeserializeWith(serde_with::As::<
4574												serde_with::OneOrMany<serde_with::Same>,
4575											>::deserialize(deserializer)?))
4576										}
4577									}
4578									match map.next_value::<DeserializeWith>() {
4579										Ok(deserialize_with) => deserialize_with.0,
4580										Err(err) => {
4581											return Err(err);
4582										}
4583									}
4584								});
4585							}
4586							Field::PurchaseDate => {
4587								if r#purchase_date_property.is_some() {
4588									return Err(<A::Error as de::Error>::duplicate_field(
4589										"purchaseDate",
4590									));
4591								}
4592								r#purchase_date_property = Some({
4593									struct DeserializeWith(Vec<PurchaseDateProperty>);
4594									impl<'de> Deserialize<'de> for DeserializeWith {
4595										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4596										where
4597											D: Deserializer<'de>,
4598										{
4599											Ok(DeserializeWith(serde_with::As::<
4600												serde_with::OneOrMany<serde_with::Same>,
4601											>::deserialize(deserializer)?))
4602										}
4603									}
4604									match map.next_value::<DeserializeWith>() {
4605										Ok(deserialize_with) => deserialize_with.0,
4606										Err(err) => {
4607											return Err(err);
4608										}
4609									}
4610								});
4611							}
4612							Field::ReleaseDate => {
4613								if r#release_date_property.is_some() {
4614									return Err(<A::Error as de::Error>::duplicate_field(
4615										"releaseDate",
4616									));
4617								}
4618								r#release_date_property = Some({
4619									struct DeserializeWith(Vec<ReleaseDateProperty>);
4620									impl<'de> Deserialize<'de> for DeserializeWith {
4621										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4622										where
4623											D: Deserializer<'de>,
4624										{
4625											Ok(DeserializeWith(serde_with::As::<
4626												serde_with::OneOrMany<serde_with::Same>,
4627											>::deserialize(deserializer)?))
4628										}
4629									}
4630									match map.next_value::<DeserializeWith>() {
4631										Ok(deserialize_with) => deserialize_with.0,
4632										Err(err) => {
4633											return Err(err);
4634										}
4635									}
4636								});
4637							}
4638							Field::Review => {
4639								if r#review_property.is_some() {
4640									return Err(<A::Error as de::Error>::duplicate_field("review"));
4641								}
4642								r#review_property = Some({
4643									struct DeserializeWith(Vec<ReviewProperty>);
4644									impl<'de> Deserialize<'de> for DeserializeWith {
4645										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4646										where
4647											D: Deserializer<'de>,
4648										{
4649											Ok(DeserializeWith(serde_with::As::<
4650												serde_with::OneOrMany<serde_with::Same>,
4651											>::deserialize(deserializer)?))
4652										}
4653									}
4654									match map.next_value::<DeserializeWith>() {
4655										Ok(deserialize_with) => deserialize_with.0,
4656										Err(err) => {
4657											return Err(err);
4658										}
4659									}
4660								});
4661							}
4662							Field::Reviews => {
4663								if r#reviews_property.is_some() {
4664									return Err(<A::Error as de::Error>::duplicate_field(
4665										"reviews",
4666									));
4667								}
4668								r#reviews_property = Some({
4669									struct DeserializeWith(Vec<ReviewsProperty>);
4670									impl<'de> Deserialize<'de> for DeserializeWith {
4671										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4672										where
4673											D: Deserializer<'de>,
4674										{
4675											Ok(DeserializeWith(serde_with::As::<
4676												serde_with::OneOrMany<serde_with::Same>,
4677											>::deserialize(deserializer)?))
4678										}
4679									}
4680									match map.next_value::<DeserializeWith>() {
4681										Ok(deserialize_with) => deserialize_with.0,
4682										Err(err) => {
4683											return Err(err);
4684										}
4685									}
4686								});
4687							}
4688							Field::Size => {
4689								if r#size_property.is_some() {
4690									return Err(<A::Error as de::Error>::duplicate_field("size"));
4691								}
4692								r#size_property = Some({
4693									struct DeserializeWith(Vec<SizeProperty>);
4694									impl<'de> Deserialize<'de> for DeserializeWith {
4695										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4696										where
4697											D: Deserializer<'de>,
4698										{
4699											Ok(DeserializeWith(serde_with::As::<
4700												serde_with::OneOrMany<serde_with::Same>,
4701											>::deserialize(deserializer)?))
4702										}
4703									}
4704									match map.next_value::<DeserializeWith>() {
4705										Ok(deserialize_with) => deserialize_with.0,
4706										Err(err) => {
4707											return Err(err);
4708										}
4709									}
4710								});
4711							}
4712							Field::Sku => {
4713								if r#sku_property.is_some() {
4714									return Err(<A::Error as de::Error>::duplicate_field("sku"));
4715								}
4716								r#sku_property = Some({
4717									struct DeserializeWith(Vec<SkuProperty>);
4718									impl<'de> Deserialize<'de> for DeserializeWith {
4719										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4720										where
4721											D: Deserializer<'de>,
4722										{
4723											Ok(DeserializeWith(serde_with::As::<
4724												serde_with::OneOrMany<serde_with::Same>,
4725											>::deserialize(deserializer)?))
4726										}
4727									}
4728									match map.next_value::<DeserializeWith>() {
4729										Ok(deserialize_with) => deserialize_with.0,
4730										Err(err) => {
4731											return Err(err);
4732										}
4733									}
4734								});
4735							}
4736							Field::Slogan => {
4737								if r#slogan_property.is_some() {
4738									return Err(<A::Error as de::Error>::duplicate_field("slogan"));
4739								}
4740								r#slogan_property = Some({
4741									struct DeserializeWith(Vec<SloganProperty>);
4742									impl<'de> Deserialize<'de> for DeserializeWith {
4743										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4744										where
4745											D: Deserializer<'de>,
4746										{
4747											Ok(DeserializeWith(serde_with::As::<
4748												serde_with::OneOrMany<serde_with::Same>,
4749											>::deserialize(deserializer)?))
4750										}
4751									}
4752									match map.next_value::<DeserializeWith>() {
4753										Ok(deserialize_with) => deserialize_with.0,
4754										Err(err) => {
4755											return Err(err);
4756										}
4757									}
4758								});
4759							}
4760							Field::Weight => {
4761								if r#weight_property.is_some() {
4762									return Err(<A::Error as de::Error>::duplicate_field("weight"));
4763								}
4764								r#weight_property = Some({
4765									struct DeserializeWith(Vec<WeightProperty>);
4766									impl<'de> Deserialize<'de> for DeserializeWith {
4767										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4768										where
4769											D: Deserializer<'de>,
4770										{
4771											Ok(DeserializeWith(serde_with::As::<
4772												serde_with::OneOrMany<serde_with::Same>,
4773											>::deserialize(deserializer)?))
4774										}
4775									}
4776									match map.next_value::<DeserializeWith>() {
4777										Ok(deserialize_with) => deserialize_with.0,
4778										Err(err) => {
4779											return Err(err);
4780										}
4781									}
4782								});
4783							}
4784							Field::Width => {
4785								if r#width_property.is_some() {
4786									return Err(<A::Error as de::Error>::duplicate_field("width"));
4787								}
4788								r#width_property = Some({
4789									struct DeserializeWith(Vec<WidthProperty>);
4790									impl<'de> Deserialize<'de> for DeserializeWith {
4791										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4792										where
4793											D: Deserializer<'de>,
4794										{
4795											Ok(DeserializeWith(serde_with::As::<
4796												serde_with::OneOrMany<serde_with::Same>,
4797											>::deserialize(deserializer)?))
4798										}
4799									}
4800									match map.next_value::<DeserializeWith>() {
4801										Ok(deserialize_with) => deserialize_with.0,
4802										Err(err) => {
4803											return Err(err);
4804										}
4805									}
4806								});
4807							}
4808							Field::AdditionalType => {
4809								if r#additional_type_property.is_some() {
4810									return Err(<A::Error as de::Error>::duplicate_field(
4811										"additionalType",
4812									));
4813								}
4814								r#additional_type_property = Some({
4815									struct DeserializeWith(Vec<AdditionalTypeProperty>);
4816									impl<'de> Deserialize<'de> for DeserializeWith {
4817										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4818										where
4819											D: Deserializer<'de>,
4820										{
4821											Ok(DeserializeWith(serde_with::As::<
4822												serde_with::OneOrMany<serde_with::Same>,
4823											>::deserialize(deserializer)?))
4824										}
4825									}
4826									match map.next_value::<DeserializeWith>() {
4827										Ok(deserialize_with) => deserialize_with.0,
4828										Err(err) => {
4829											return Err(err);
4830										}
4831									}
4832								});
4833							}
4834							Field::AlternateName => {
4835								if r#alternate_name_property.is_some() {
4836									return Err(<A::Error as de::Error>::duplicate_field(
4837										"alternateName",
4838									));
4839								}
4840								r#alternate_name_property = Some({
4841									struct DeserializeWith(Vec<AlternateNameProperty>);
4842									impl<'de> Deserialize<'de> for DeserializeWith {
4843										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4844										where
4845											D: Deserializer<'de>,
4846										{
4847											Ok(DeserializeWith(serde_with::As::<
4848												serde_with::OneOrMany<serde_with::Same>,
4849											>::deserialize(deserializer)?))
4850										}
4851									}
4852									match map.next_value::<DeserializeWith>() {
4853										Ok(deserialize_with) => deserialize_with.0,
4854										Err(err) => {
4855											return Err(err);
4856										}
4857									}
4858								});
4859							}
4860							Field::Description => {
4861								if r#description_property.is_some() {
4862									return Err(<A::Error as de::Error>::duplicate_field(
4863										"description",
4864									));
4865								}
4866								r#description_property = Some({
4867									struct DeserializeWith(Vec<DescriptionProperty>);
4868									impl<'de> Deserialize<'de> for DeserializeWith {
4869										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4870										where
4871											D: Deserializer<'de>,
4872										{
4873											Ok(DeserializeWith(serde_with::As::<
4874												serde_with::OneOrMany<serde_with::Same>,
4875											>::deserialize(deserializer)?))
4876										}
4877									}
4878									match map.next_value::<DeserializeWith>() {
4879										Ok(deserialize_with) => deserialize_with.0,
4880										Err(err) => {
4881											return Err(err);
4882										}
4883									}
4884								});
4885							}
4886							Field::DisambiguatingDescription => {
4887								if r#disambiguating_description_property.is_some() {
4888									return Err(<A::Error as de::Error>::duplicate_field(
4889										"disambiguatingDescription",
4890									));
4891								}
4892								r#disambiguating_description_property = Some({
4893									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
4894									impl<'de> Deserialize<'de> for DeserializeWith {
4895										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4896										where
4897											D: Deserializer<'de>,
4898										{
4899											Ok(DeserializeWith(serde_with::As::<
4900												serde_with::OneOrMany<serde_with::Same>,
4901											>::deserialize(deserializer)?))
4902										}
4903									}
4904									match map.next_value::<DeserializeWith>() {
4905										Ok(deserialize_with) => deserialize_with.0,
4906										Err(err) => {
4907											return Err(err);
4908										}
4909									}
4910								});
4911							}
4912							Field::Identifier => {
4913								if r#identifier_property.is_some() {
4914									return Err(<A::Error as de::Error>::duplicate_field(
4915										"identifier",
4916									));
4917								}
4918								r#identifier_property = Some({
4919									struct DeserializeWith(Vec<IdentifierProperty>);
4920									impl<'de> Deserialize<'de> for DeserializeWith {
4921										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4922										where
4923											D: Deserializer<'de>,
4924										{
4925											Ok(DeserializeWith(serde_with::As::<
4926												serde_with::OneOrMany<serde_with::Same>,
4927											>::deserialize(deserializer)?))
4928										}
4929									}
4930									match map.next_value::<DeserializeWith>() {
4931										Ok(deserialize_with) => deserialize_with.0,
4932										Err(err) => {
4933											return Err(err);
4934										}
4935									}
4936								});
4937							}
4938							Field::Image => {
4939								if r#image_property.is_some() {
4940									return Err(<A::Error as de::Error>::duplicate_field("image"));
4941								}
4942								r#image_property = Some({
4943									struct DeserializeWith(Vec<ImageProperty>);
4944									impl<'de> Deserialize<'de> for DeserializeWith {
4945										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4946										where
4947											D: Deserializer<'de>,
4948										{
4949											Ok(DeserializeWith(serde_with::As::<
4950												serde_with::OneOrMany<serde_with::Same>,
4951											>::deserialize(deserializer)?))
4952										}
4953									}
4954									match map.next_value::<DeserializeWith>() {
4955										Ok(deserialize_with) => deserialize_with.0,
4956										Err(err) => {
4957											return Err(err);
4958										}
4959									}
4960								});
4961							}
4962							Field::MainEntityOfPage => {
4963								if r#main_entity_of_page_property.is_some() {
4964									return Err(<A::Error as de::Error>::duplicate_field(
4965										"mainEntityOfPage",
4966									));
4967								}
4968								r#main_entity_of_page_property = Some({
4969									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
4970									impl<'de> Deserialize<'de> for DeserializeWith {
4971										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4972										where
4973											D: Deserializer<'de>,
4974										{
4975											Ok(DeserializeWith(serde_with::As::<
4976												serde_with::OneOrMany<serde_with::Same>,
4977											>::deserialize(deserializer)?))
4978										}
4979									}
4980									match map.next_value::<DeserializeWith>() {
4981										Ok(deserialize_with) => deserialize_with.0,
4982										Err(err) => {
4983											return Err(err);
4984										}
4985									}
4986								});
4987							}
4988							Field::Name => {
4989								if r#name_property.is_some() {
4990									return Err(<A::Error as de::Error>::duplicate_field("name"));
4991								}
4992								r#name_property = Some({
4993									struct DeserializeWith(Vec<NameProperty>);
4994									impl<'de> Deserialize<'de> for DeserializeWith {
4995										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4996										where
4997											D: Deserializer<'de>,
4998										{
4999											Ok(DeserializeWith(serde_with::As::<
5000												serde_with::OneOrMany<serde_with::Same>,
5001											>::deserialize(deserializer)?))
5002										}
5003									}
5004									match map.next_value::<DeserializeWith>() {
5005										Ok(deserialize_with) => deserialize_with.0,
5006										Err(err) => {
5007											return Err(err);
5008										}
5009									}
5010								});
5011							}
5012							Field::PotentialAction => {
5013								if r#potential_action_property.is_some() {
5014									return Err(<A::Error as de::Error>::duplicate_field(
5015										"potentialAction",
5016									));
5017								}
5018								r#potential_action_property = Some({
5019									struct DeserializeWith(Vec<PotentialActionProperty>);
5020									impl<'de> Deserialize<'de> for DeserializeWith {
5021										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5022										where
5023											D: Deserializer<'de>,
5024										{
5025											Ok(DeserializeWith(serde_with::As::<
5026												serde_with::OneOrMany<serde_with::Same>,
5027											>::deserialize(deserializer)?))
5028										}
5029									}
5030									match map.next_value::<DeserializeWith>() {
5031										Ok(deserialize_with) => deserialize_with.0,
5032										Err(err) => {
5033											return Err(err);
5034										}
5035									}
5036								});
5037							}
5038							Field::SameAs => {
5039								if r#same_as_property.is_some() {
5040									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
5041								}
5042								r#same_as_property = Some({
5043									struct DeserializeWith(Vec<SameAsProperty>);
5044									impl<'de> Deserialize<'de> for DeserializeWith {
5045										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5046										where
5047											D: Deserializer<'de>,
5048										{
5049											Ok(DeserializeWith(serde_with::As::<
5050												serde_with::OneOrMany<serde_with::Same>,
5051											>::deserialize(deserializer)?))
5052										}
5053									}
5054									match map.next_value::<DeserializeWith>() {
5055										Ok(deserialize_with) => deserialize_with.0,
5056										Err(err) => {
5057											return Err(err);
5058										}
5059									}
5060								});
5061							}
5062							Field::SubjectOf => {
5063								if r#subject_of_property.is_some() {
5064									return Err(<A::Error as de::Error>::duplicate_field(
5065										"subjectOf",
5066									));
5067								}
5068								r#subject_of_property = Some({
5069									struct DeserializeWith(Vec<SubjectOfProperty>);
5070									impl<'de> Deserialize<'de> for DeserializeWith {
5071										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5072										where
5073											D: Deserializer<'de>,
5074										{
5075											Ok(DeserializeWith(serde_with::As::<
5076												serde_with::OneOrMany<serde_with::Same>,
5077											>::deserialize(deserializer)?))
5078										}
5079									}
5080									match map.next_value::<DeserializeWith>() {
5081										Ok(deserialize_with) => deserialize_with.0,
5082										Err(err) => {
5083											return Err(err);
5084										}
5085									}
5086								});
5087							}
5088							Field::Url => {
5089								if r#url_property.is_some() {
5090									return Err(<A::Error as de::Error>::duplicate_field("url"));
5091								}
5092								r#url_property = Some({
5093									struct DeserializeWith(Vec<UrlProperty>);
5094									impl<'de> Deserialize<'de> for DeserializeWith {
5095										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5096										where
5097											D: Deserializer<'de>,
5098										{
5099											Ok(DeserializeWith(serde_with::As::<
5100												serde_with::OneOrMany<serde_with::Same>,
5101											>::deserialize(deserializer)?))
5102										}
5103									}
5104									match map.next_value::<DeserializeWith>() {
5105										Ok(deserialize_with) => deserialize_with.0,
5106										Err(err) => {
5107											return Err(err);
5108										}
5109									}
5110								});
5111							}
5112							Field::AccelerationTime => {
5113								if r#acceleration_time_property.is_some() {
5114									return Err(<A::Error as de::Error>::duplicate_field(
5115										"accelerationTime",
5116									));
5117								}
5118								r#acceleration_time_property = Some({
5119									struct DeserializeWith(Vec<AccelerationTimeProperty>);
5120									impl<'de> Deserialize<'de> for DeserializeWith {
5121										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5122										where
5123											D: Deserializer<'de>,
5124										{
5125											Ok(DeserializeWith(serde_with::As::<
5126												serde_with::OneOrMany<serde_with::Same>,
5127											>::deserialize(deserializer)?))
5128										}
5129									}
5130									match map.next_value::<DeserializeWith>() {
5131										Ok(deserialize_with) => deserialize_with.0,
5132										Err(err) => {
5133											return Err(err);
5134										}
5135									}
5136								});
5137							}
5138							Field::BodyType => {
5139								if r#body_type_property.is_some() {
5140									return Err(<A::Error as de::Error>::duplicate_field(
5141										"bodyType",
5142									));
5143								}
5144								r#body_type_property = Some({
5145									struct DeserializeWith(Vec<BodyTypeProperty>);
5146									impl<'de> Deserialize<'de> for DeserializeWith {
5147										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5148										where
5149											D: Deserializer<'de>,
5150										{
5151											Ok(DeserializeWith(serde_with::As::<
5152												serde_with::OneOrMany<serde_with::Same>,
5153											>::deserialize(deserializer)?))
5154										}
5155									}
5156									match map.next_value::<DeserializeWith>() {
5157										Ok(deserialize_with) => deserialize_with.0,
5158										Err(err) => {
5159											return Err(err);
5160										}
5161									}
5162								});
5163							}
5164							Field::CallSign => {
5165								if r#call_sign_property.is_some() {
5166									return Err(<A::Error as de::Error>::duplicate_field(
5167										"callSign",
5168									));
5169								}
5170								r#call_sign_property = Some({
5171									struct DeserializeWith(Vec<CallSignProperty>);
5172									impl<'de> Deserialize<'de> for DeserializeWith {
5173										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5174										where
5175											D: Deserializer<'de>,
5176										{
5177											Ok(DeserializeWith(serde_with::As::<
5178												serde_with::OneOrMany<serde_with::Same>,
5179											>::deserialize(deserializer)?))
5180										}
5181									}
5182									match map.next_value::<DeserializeWith>() {
5183										Ok(deserialize_with) => deserialize_with.0,
5184										Err(err) => {
5185											return Err(err);
5186										}
5187									}
5188								});
5189							}
5190							Field::CargoVolume => {
5191								if r#cargo_volume_property.is_some() {
5192									return Err(<A::Error as de::Error>::duplicate_field(
5193										"cargoVolume",
5194									));
5195								}
5196								r#cargo_volume_property = Some({
5197									struct DeserializeWith(Vec<CargoVolumeProperty>);
5198									impl<'de> Deserialize<'de> for DeserializeWith {
5199										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5200										where
5201											D: Deserializer<'de>,
5202										{
5203											Ok(DeserializeWith(serde_with::As::<
5204												serde_with::OneOrMany<serde_with::Same>,
5205											>::deserialize(deserializer)?))
5206										}
5207									}
5208									match map.next_value::<DeserializeWith>() {
5209										Ok(deserialize_with) => deserialize_with.0,
5210										Err(err) => {
5211											return Err(err);
5212										}
5213									}
5214								});
5215							}
5216							Field::DateVehicleFirstRegistered => {
5217								if r#date_vehicle_first_registered_property.is_some() {
5218									return Err(<A::Error as de::Error>::duplicate_field(
5219										"dateVehicleFirstRegistered",
5220									));
5221								}
5222								r#date_vehicle_first_registered_property = Some({
5223									struct DeserializeWith(Vec<DateVehicleFirstRegisteredProperty>);
5224									impl<'de> Deserialize<'de> for DeserializeWith {
5225										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5226										where
5227											D: Deserializer<'de>,
5228										{
5229											Ok(DeserializeWith(serde_with::As::<
5230												serde_with::OneOrMany<serde_with::Same>,
5231											>::deserialize(deserializer)?))
5232										}
5233									}
5234									match map.next_value::<DeserializeWith>() {
5235										Ok(deserialize_with) => deserialize_with.0,
5236										Err(err) => {
5237											return Err(err);
5238										}
5239									}
5240								});
5241							}
5242							Field::DriveWheelConfiguration => {
5243								if r#drive_wheel_configuration_property.is_some() {
5244									return Err(<A::Error as de::Error>::duplicate_field(
5245										"driveWheelConfiguration",
5246									));
5247								}
5248								r#drive_wheel_configuration_property = Some({
5249									struct DeserializeWith(Vec<DriveWheelConfigurationProperty>);
5250									impl<'de> Deserialize<'de> for DeserializeWith {
5251										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5252										where
5253											D: Deserializer<'de>,
5254										{
5255											Ok(DeserializeWith(serde_with::As::<
5256												serde_with::OneOrMany<serde_with::Same>,
5257											>::deserialize(deserializer)?))
5258										}
5259									}
5260									match map.next_value::<DeserializeWith>() {
5261										Ok(deserialize_with) => deserialize_with.0,
5262										Err(err) => {
5263											return Err(err);
5264										}
5265									}
5266								});
5267							}
5268							Field::EmissionsCo2 => {
5269								if r#emissions_co_2_property.is_some() {
5270									return Err(<A::Error as de::Error>::duplicate_field(
5271										"emissionsCO2",
5272									));
5273								}
5274								r#emissions_co_2_property = Some({
5275									struct DeserializeWith(Vec<EmissionsCo2Property>);
5276									impl<'de> Deserialize<'de> for DeserializeWith {
5277										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5278										where
5279											D: Deserializer<'de>,
5280										{
5281											Ok(DeserializeWith(serde_with::As::<
5282												serde_with::OneOrMany<serde_with::Same>,
5283											>::deserialize(deserializer)?))
5284										}
5285									}
5286									match map.next_value::<DeserializeWith>() {
5287										Ok(deserialize_with) => deserialize_with.0,
5288										Err(err) => {
5289											return Err(err);
5290										}
5291									}
5292								});
5293							}
5294							Field::FuelCapacity => {
5295								if r#fuel_capacity_property.is_some() {
5296									return Err(<A::Error as de::Error>::duplicate_field(
5297										"fuelCapacity",
5298									));
5299								}
5300								r#fuel_capacity_property = Some({
5301									struct DeserializeWith(Vec<FuelCapacityProperty>);
5302									impl<'de> Deserialize<'de> for DeserializeWith {
5303										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5304										where
5305											D: Deserializer<'de>,
5306										{
5307											Ok(DeserializeWith(serde_with::As::<
5308												serde_with::OneOrMany<serde_with::Same>,
5309											>::deserialize(deserializer)?))
5310										}
5311									}
5312									match map.next_value::<DeserializeWith>() {
5313										Ok(deserialize_with) => deserialize_with.0,
5314										Err(err) => {
5315											return Err(err);
5316										}
5317									}
5318								});
5319							}
5320							Field::FuelConsumption => {
5321								if r#fuel_consumption_property.is_some() {
5322									return Err(<A::Error as de::Error>::duplicate_field(
5323										"fuelConsumption",
5324									));
5325								}
5326								r#fuel_consumption_property = Some({
5327									struct DeserializeWith(Vec<FuelConsumptionProperty>);
5328									impl<'de> Deserialize<'de> for DeserializeWith {
5329										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5330										where
5331											D: Deserializer<'de>,
5332										{
5333											Ok(DeserializeWith(serde_with::As::<
5334												serde_with::OneOrMany<serde_with::Same>,
5335											>::deserialize(deserializer)?))
5336										}
5337									}
5338									match map.next_value::<DeserializeWith>() {
5339										Ok(deserialize_with) => deserialize_with.0,
5340										Err(err) => {
5341											return Err(err);
5342										}
5343									}
5344								});
5345							}
5346							Field::FuelEfficiency => {
5347								if r#fuel_efficiency_property.is_some() {
5348									return Err(<A::Error as de::Error>::duplicate_field(
5349										"fuelEfficiency",
5350									));
5351								}
5352								r#fuel_efficiency_property = Some({
5353									struct DeserializeWith(Vec<FuelEfficiencyProperty>);
5354									impl<'de> Deserialize<'de> for DeserializeWith {
5355										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5356										where
5357											D: Deserializer<'de>,
5358										{
5359											Ok(DeserializeWith(serde_with::As::<
5360												serde_with::OneOrMany<serde_with::Same>,
5361											>::deserialize(deserializer)?))
5362										}
5363									}
5364									match map.next_value::<DeserializeWith>() {
5365										Ok(deserialize_with) => deserialize_with.0,
5366										Err(err) => {
5367											return Err(err);
5368										}
5369									}
5370								});
5371							}
5372							Field::FuelType => {
5373								if r#fuel_type_property.is_some() {
5374									return Err(<A::Error as de::Error>::duplicate_field(
5375										"fuelType",
5376									));
5377								}
5378								r#fuel_type_property = Some({
5379									struct DeserializeWith(Vec<FuelTypeProperty>);
5380									impl<'de> Deserialize<'de> for DeserializeWith {
5381										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5382										where
5383											D: Deserializer<'de>,
5384										{
5385											Ok(DeserializeWith(serde_with::As::<
5386												serde_with::OneOrMany<serde_with::Same>,
5387											>::deserialize(deserializer)?))
5388										}
5389									}
5390									match map.next_value::<DeserializeWith>() {
5391										Ok(deserialize_with) => deserialize_with.0,
5392										Err(err) => {
5393											return Err(err);
5394										}
5395									}
5396								});
5397							}
5398							Field::KnownVehicleDamages => {
5399								if r#known_vehicle_damages_property.is_some() {
5400									return Err(<A::Error as de::Error>::duplicate_field(
5401										"knownVehicleDamages",
5402									));
5403								}
5404								r#known_vehicle_damages_property = Some({
5405									struct DeserializeWith(Vec<KnownVehicleDamagesProperty>);
5406									impl<'de> Deserialize<'de> for DeserializeWith {
5407										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5408										where
5409											D: Deserializer<'de>,
5410										{
5411											Ok(DeserializeWith(serde_with::As::<
5412												serde_with::OneOrMany<serde_with::Same>,
5413											>::deserialize(deserializer)?))
5414										}
5415									}
5416									match map.next_value::<DeserializeWith>() {
5417										Ok(deserialize_with) => deserialize_with.0,
5418										Err(err) => {
5419											return Err(err);
5420										}
5421									}
5422								});
5423							}
5424							Field::MeetsEmissionStandard => {
5425								if r#meets_emission_standard_property.is_some() {
5426									return Err(<A::Error as de::Error>::duplicate_field(
5427										"meetsEmissionStandard",
5428									));
5429								}
5430								r#meets_emission_standard_property = Some({
5431									struct DeserializeWith(Vec<MeetsEmissionStandardProperty>);
5432									impl<'de> Deserialize<'de> for DeserializeWith {
5433										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5434										where
5435											D: Deserializer<'de>,
5436										{
5437											Ok(DeserializeWith(serde_with::As::<
5438												serde_with::OneOrMany<serde_with::Same>,
5439											>::deserialize(deserializer)?))
5440										}
5441									}
5442									match map.next_value::<DeserializeWith>() {
5443										Ok(deserialize_with) => deserialize_with.0,
5444										Err(err) => {
5445											return Err(err);
5446										}
5447									}
5448								});
5449							}
5450							Field::MileageFromOdometer => {
5451								if r#mileage_from_odometer_property.is_some() {
5452									return Err(<A::Error as de::Error>::duplicate_field(
5453										"mileageFromOdometer",
5454									));
5455								}
5456								r#mileage_from_odometer_property = Some({
5457									struct DeserializeWith(Vec<MileageFromOdometerProperty>);
5458									impl<'de> Deserialize<'de> for DeserializeWith {
5459										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5460										where
5461											D: Deserializer<'de>,
5462										{
5463											Ok(DeserializeWith(serde_with::As::<
5464												serde_with::OneOrMany<serde_with::Same>,
5465											>::deserialize(deserializer)?))
5466										}
5467									}
5468									match map.next_value::<DeserializeWith>() {
5469										Ok(deserialize_with) => deserialize_with.0,
5470										Err(err) => {
5471											return Err(err);
5472										}
5473									}
5474								});
5475							}
5476							Field::ModelDate => {
5477								if r#model_date_property.is_some() {
5478									return Err(<A::Error as de::Error>::duplicate_field(
5479										"modelDate",
5480									));
5481								}
5482								r#model_date_property = Some({
5483									struct DeserializeWith(Vec<ModelDateProperty>);
5484									impl<'de> Deserialize<'de> for DeserializeWith {
5485										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5486										where
5487											D: Deserializer<'de>,
5488										{
5489											Ok(DeserializeWith(serde_with::As::<
5490												serde_with::OneOrMany<serde_with::Same>,
5491											>::deserialize(deserializer)?))
5492										}
5493									}
5494									match map.next_value::<DeserializeWith>() {
5495										Ok(deserialize_with) => deserialize_with.0,
5496										Err(err) => {
5497											return Err(err);
5498										}
5499									}
5500								});
5501							}
5502							Field::NumberOfAirbags => {
5503								if r#number_of_airbags_property.is_some() {
5504									return Err(<A::Error as de::Error>::duplicate_field(
5505										"numberOfAirbags",
5506									));
5507								}
5508								r#number_of_airbags_property = Some({
5509									struct DeserializeWith(Vec<NumberOfAirbagsProperty>);
5510									impl<'de> Deserialize<'de> for DeserializeWith {
5511										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5512										where
5513											D: Deserializer<'de>,
5514										{
5515											Ok(DeserializeWith(serde_with::As::<
5516												serde_with::OneOrMany<serde_with::Same>,
5517											>::deserialize(deserializer)?))
5518										}
5519									}
5520									match map.next_value::<DeserializeWith>() {
5521										Ok(deserialize_with) => deserialize_with.0,
5522										Err(err) => {
5523											return Err(err);
5524										}
5525									}
5526								});
5527							}
5528							Field::NumberOfAxles => {
5529								if r#number_of_axles_property.is_some() {
5530									return Err(<A::Error as de::Error>::duplicate_field(
5531										"numberOfAxles",
5532									));
5533								}
5534								r#number_of_axles_property = Some({
5535									struct DeserializeWith(Vec<NumberOfAxlesProperty>);
5536									impl<'de> Deserialize<'de> for DeserializeWith {
5537										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5538										where
5539											D: Deserializer<'de>,
5540										{
5541											Ok(DeserializeWith(serde_with::As::<
5542												serde_with::OneOrMany<serde_with::Same>,
5543											>::deserialize(deserializer)?))
5544										}
5545									}
5546									match map.next_value::<DeserializeWith>() {
5547										Ok(deserialize_with) => deserialize_with.0,
5548										Err(err) => {
5549											return Err(err);
5550										}
5551									}
5552								});
5553							}
5554							Field::NumberOfDoors => {
5555								if r#number_of_doors_property.is_some() {
5556									return Err(<A::Error as de::Error>::duplicate_field(
5557										"numberOfDoors",
5558									));
5559								}
5560								r#number_of_doors_property = Some({
5561									struct DeserializeWith(Vec<NumberOfDoorsProperty>);
5562									impl<'de> Deserialize<'de> for DeserializeWith {
5563										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5564										where
5565											D: Deserializer<'de>,
5566										{
5567											Ok(DeserializeWith(serde_with::As::<
5568												serde_with::OneOrMany<serde_with::Same>,
5569											>::deserialize(deserializer)?))
5570										}
5571									}
5572									match map.next_value::<DeserializeWith>() {
5573										Ok(deserialize_with) => deserialize_with.0,
5574										Err(err) => {
5575											return Err(err);
5576										}
5577									}
5578								});
5579							}
5580							Field::NumberOfForwardGears => {
5581								if r#number_of_forward_gears_property.is_some() {
5582									return Err(<A::Error as de::Error>::duplicate_field(
5583										"numberOfForwardGears",
5584									));
5585								}
5586								r#number_of_forward_gears_property = Some({
5587									struct DeserializeWith(Vec<NumberOfForwardGearsProperty>);
5588									impl<'de> Deserialize<'de> for DeserializeWith {
5589										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5590										where
5591											D: Deserializer<'de>,
5592										{
5593											Ok(DeserializeWith(serde_with::As::<
5594												serde_with::OneOrMany<serde_with::Same>,
5595											>::deserialize(deserializer)?))
5596										}
5597									}
5598									match map.next_value::<DeserializeWith>() {
5599										Ok(deserialize_with) => deserialize_with.0,
5600										Err(err) => {
5601											return Err(err);
5602										}
5603									}
5604								});
5605							}
5606							Field::NumberOfPreviousOwners => {
5607								if r#number_of_previous_owners_property.is_some() {
5608									return Err(<A::Error as de::Error>::duplicate_field(
5609										"numberOfPreviousOwners",
5610									));
5611								}
5612								r#number_of_previous_owners_property = Some({
5613									struct DeserializeWith(Vec<NumberOfPreviousOwnersProperty>);
5614									impl<'de> Deserialize<'de> for DeserializeWith {
5615										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5616										where
5617											D: Deserializer<'de>,
5618										{
5619											Ok(DeserializeWith(serde_with::As::<
5620												serde_with::OneOrMany<serde_with::Same>,
5621											>::deserialize(deserializer)?))
5622										}
5623									}
5624									match map.next_value::<DeserializeWith>() {
5625										Ok(deserialize_with) => deserialize_with.0,
5626										Err(err) => {
5627											return Err(err);
5628										}
5629									}
5630								});
5631							}
5632							Field::Payload => {
5633								if r#payload_property.is_some() {
5634									return Err(<A::Error as de::Error>::duplicate_field(
5635										"payload",
5636									));
5637								}
5638								r#payload_property = Some({
5639									struct DeserializeWith(Vec<PayloadProperty>);
5640									impl<'de> Deserialize<'de> for DeserializeWith {
5641										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5642										where
5643											D: Deserializer<'de>,
5644										{
5645											Ok(DeserializeWith(serde_with::As::<
5646												serde_with::OneOrMany<serde_with::Same>,
5647											>::deserialize(deserializer)?))
5648										}
5649									}
5650									match map.next_value::<DeserializeWith>() {
5651										Ok(deserialize_with) => deserialize_with.0,
5652										Err(err) => {
5653											return Err(err);
5654										}
5655									}
5656								});
5657							}
5658							Field::SeatingCapacity => {
5659								if r#seating_capacity_property.is_some() {
5660									return Err(<A::Error as de::Error>::duplicate_field(
5661										"seatingCapacity",
5662									));
5663								}
5664								r#seating_capacity_property = Some({
5665									struct DeserializeWith(Vec<SeatingCapacityProperty>);
5666									impl<'de> Deserialize<'de> for DeserializeWith {
5667										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5668										where
5669											D: Deserializer<'de>,
5670										{
5671											Ok(DeserializeWith(serde_with::As::<
5672												serde_with::OneOrMany<serde_with::Same>,
5673											>::deserialize(deserializer)?))
5674										}
5675									}
5676									match map.next_value::<DeserializeWith>() {
5677										Ok(deserialize_with) => deserialize_with.0,
5678										Err(err) => {
5679											return Err(err);
5680										}
5681									}
5682								});
5683							}
5684							Field::Speed => {
5685								if r#speed_property.is_some() {
5686									return Err(<A::Error as de::Error>::duplicate_field("speed"));
5687								}
5688								r#speed_property = Some({
5689									struct DeserializeWith(Vec<SpeedProperty>);
5690									impl<'de> Deserialize<'de> for DeserializeWith {
5691										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5692										where
5693											D: Deserializer<'de>,
5694										{
5695											Ok(DeserializeWith(serde_with::As::<
5696												serde_with::OneOrMany<serde_with::Same>,
5697											>::deserialize(deserializer)?))
5698										}
5699									}
5700									match map.next_value::<DeserializeWith>() {
5701										Ok(deserialize_with) => deserialize_with.0,
5702										Err(err) => {
5703											return Err(err);
5704										}
5705									}
5706								});
5707							}
5708							Field::SteeringPosition => {
5709								if r#steering_position_property.is_some() {
5710									return Err(<A::Error as de::Error>::duplicate_field(
5711										"steeringPosition",
5712									));
5713								}
5714								r#steering_position_property = Some({
5715									struct DeserializeWith(Vec<SteeringPositionProperty>);
5716									impl<'de> Deserialize<'de> for DeserializeWith {
5717										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5718										where
5719											D: Deserializer<'de>,
5720										{
5721											Ok(DeserializeWith(serde_with::As::<
5722												serde_with::OneOrMany<serde_with::Same>,
5723											>::deserialize(deserializer)?))
5724										}
5725									}
5726									match map.next_value::<DeserializeWith>() {
5727										Ok(deserialize_with) => deserialize_with.0,
5728										Err(err) => {
5729											return Err(err);
5730										}
5731									}
5732								});
5733							}
5734							Field::StupidProperty => {
5735								if r#stupid_property_property.is_some() {
5736									return Err(<A::Error as de::Error>::duplicate_field(
5737										"stupidProperty",
5738									));
5739								}
5740								r#stupid_property_property = Some({
5741									struct DeserializeWith(Vec<StupidPropertyProperty>);
5742									impl<'de> Deserialize<'de> for DeserializeWith {
5743										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5744										where
5745											D: Deserializer<'de>,
5746										{
5747											Ok(DeserializeWith(serde_with::As::<
5748												serde_with::OneOrMany<serde_with::Same>,
5749											>::deserialize(deserializer)?))
5750										}
5751									}
5752									match map.next_value::<DeserializeWith>() {
5753										Ok(deserialize_with) => deserialize_with.0,
5754										Err(err) => {
5755											return Err(err);
5756										}
5757									}
5758								});
5759							}
5760							Field::TongueWeight => {
5761								if r#tongue_weight_property.is_some() {
5762									return Err(<A::Error as de::Error>::duplicate_field(
5763										"tongueWeight",
5764									));
5765								}
5766								r#tongue_weight_property = Some({
5767									struct DeserializeWith(Vec<TongueWeightProperty>);
5768									impl<'de> Deserialize<'de> for DeserializeWith {
5769										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5770										where
5771											D: Deserializer<'de>,
5772										{
5773											Ok(DeserializeWith(serde_with::As::<
5774												serde_with::OneOrMany<serde_with::Same>,
5775											>::deserialize(deserializer)?))
5776										}
5777									}
5778									match map.next_value::<DeserializeWith>() {
5779										Ok(deserialize_with) => deserialize_with.0,
5780										Err(err) => {
5781											return Err(err);
5782										}
5783									}
5784								});
5785							}
5786							Field::TrailerWeight => {
5787								if r#trailer_weight_property.is_some() {
5788									return Err(<A::Error as de::Error>::duplicate_field(
5789										"trailerWeight",
5790									));
5791								}
5792								r#trailer_weight_property = Some({
5793									struct DeserializeWith(Vec<TrailerWeightProperty>);
5794									impl<'de> Deserialize<'de> for DeserializeWith {
5795										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5796										where
5797											D: Deserializer<'de>,
5798										{
5799											Ok(DeserializeWith(serde_with::As::<
5800												serde_with::OneOrMany<serde_with::Same>,
5801											>::deserialize(deserializer)?))
5802										}
5803									}
5804									match map.next_value::<DeserializeWith>() {
5805										Ok(deserialize_with) => deserialize_with.0,
5806										Err(err) => {
5807											return Err(err);
5808										}
5809									}
5810								});
5811							}
5812							Field::VehicleConfiguration => {
5813								if r#vehicle_configuration_property.is_some() {
5814									return Err(<A::Error as de::Error>::duplicate_field(
5815										"vehicleConfiguration",
5816									));
5817								}
5818								r#vehicle_configuration_property = Some({
5819									struct DeserializeWith(Vec<VehicleConfigurationProperty>);
5820									impl<'de> Deserialize<'de> for DeserializeWith {
5821										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5822										where
5823											D: Deserializer<'de>,
5824										{
5825											Ok(DeserializeWith(serde_with::As::<
5826												serde_with::OneOrMany<serde_with::Same>,
5827											>::deserialize(deserializer)?))
5828										}
5829									}
5830									match map.next_value::<DeserializeWith>() {
5831										Ok(deserialize_with) => deserialize_with.0,
5832										Err(err) => {
5833											return Err(err);
5834										}
5835									}
5836								});
5837							}
5838							Field::VehicleEngine => {
5839								if r#vehicle_engine_property.is_some() {
5840									return Err(<A::Error as de::Error>::duplicate_field(
5841										"vehicleEngine",
5842									));
5843								}
5844								r#vehicle_engine_property = Some({
5845									struct DeserializeWith(Vec<VehicleEngineProperty>);
5846									impl<'de> Deserialize<'de> for DeserializeWith {
5847										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5848										where
5849											D: Deserializer<'de>,
5850										{
5851											Ok(DeserializeWith(serde_with::As::<
5852												serde_with::OneOrMany<serde_with::Same>,
5853											>::deserialize(deserializer)?))
5854										}
5855									}
5856									match map.next_value::<DeserializeWith>() {
5857										Ok(deserialize_with) => deserialize_with.0,
5858										Err(err) => {
5859											return Err(err);
5860										}
5861									}
5862								});
5863							}
5864							Field::VehicleIdentificationNumber => {
5865								if r#vehicle_identification_number_property.is_some() {
5866									return Err(<A::Error as de::Error>::duplicate_field(
5867										"vehicleIdentificationNumber",
5868									));
5869								}
5870								r#vehicle_identification_number_property = Some({
5871									struct DeserializeWith(
5872										Vec<VehicleIdentificationNumberProperty>,
5873									);
5874									impl<'de> Deserialize<'de> for DeserializeWith {
5875										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5876										where
5877											D: Deserializer<'de>,
5878										{
5879											Ok(DeserializeWith(serde_with::As::<
5880												serde_with::OneOrMany<serde_with::Same>,
5881											>::deserialize(deserializer)?))
5882										}
5883									}
5884									match map.next_value::<DeserializeWith>() {
5885										Ok(deserialize_with) => deserialize_with.0,
5886										Err(err) => {
5887											return Err(err);
5888										}
5889									}
5890								});
5891							}
5892							Field::VehicleInteriorColor => {
5893								if r#vehicle_interior_color_property.is_some() {
5894									return Err(<A::Error as de::Error>::duplicate_field(
5895										"vehicleInteriorColor",
5896									));
5897								}
5898								r#vehicle_interior_color_property = Some({
5899									struct DeserializeWith(Vec<VehicleInteriorColorProperty>);
5900									impl<'de> Deserialize<'de> for DeserializeWith {
5901										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5902										where
5903											D: Deserializer<'de>,
5904										{
5905											Ok(DeserializeWith(serde_with::As::<
5906												serde_with::OneOrMany<serde_with::Same>,
5907											>::deserialize(deserializer)?))
5908										}
5909									}
5910									match map.next_value::<DeserializeWith>() {
5911										Ok(deserialize_with) => deserialize_with.0,
5912										Err(err) => {
5913											return Err(err);
5914										}
5915									}
5916								});
5917							}
5918							Field::VehicleInteriorType => {
5919								if r#vehicle_interior_type_property.is_some() {
5920									return Err(<A::Error as de::Error>::duplicate_field(
5921										"vehicleInteriorType",
5922									));
5923								}
5924								r#vehicle_interior_type_property = Some({
5925									struct DeserializeWith(Vec<VehicleInteriorTypeProperty>);
5926									impl<'de> Deserialize<'de> for DeserializeWith {
5927										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5928										where
5929											D: Deserializer<'de>,
5930										{
5931											Ok(DeserializeWith(serde_with::As::<
5932												serde_with::OneOrMany<serde_with::Same>,
5933											>::deserialize(deserializer)?))
5934										}
5935									}
5936									match map.next_value::<DeserializeWith>() {
5937										Ok(deserialize_with) => deserialize_with.0,
5938										Err(err) => {
5939											return Err(err);
5940										}
5941									}
5942								});
5943							}
5944							Field::VehicleModelDate => {
5945								if r#vehicle_model_date_property.is_some() {
5946									return Err(<A::Error as de::Error>::duplicate_field(
5947										"vehicleModelDate",
5948									));
5949								}
5950								r#vehicle_model_date_property = Some({
5951									struct DeserializeWith(Vec<VehicleModelDateProperty>);
5952									impl<'de> Deserialize<'de> for DeserializeWith {
5953										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5954										where
5955											D: Deserializer<'de>,
5956										{
5957											Ok(DeserializeWith(serde_with::As::<
5958												serde_with::OneOrMany<serde_with::Same>,
5959											>::deserialize(deserializer)?))
5960										}
5961									}
5962									match map.next_value::<DeserializeWith>() {
5963										Ok(deserialize_with) => deserialize_with.0,
5964										Err(err) => {
5965											return Err(err);
5966										}
5967									}
5968								});
5969							}
5970							Field::VehicleSeatingCapacity => {
5971								if r#vehicle_seating_capacity_property.is_some() {
5972									return Err(<A::Error as de::Error>::duplicate_field(
5973										"vehicleSeatingCapacity",
5974									));
5975								}
5976								r#vehicle_seating_capacity_property = Some({
5977									struct DeserializeWith(Vec<VehicleSeatingCapacityProperty>);
5978									impl<'de> Deserialize<'de> for DeserializeWith {
5979										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5980										where
5981											D: Deserializer<'de>,
5982										{
5983											Ok(DeserializeWith(serde_with::As::<
5984												serde_with::OneOrMany<serde_with::Same>,
5985											>::deserialize(deserializer)?))
5986										}
5987									}
5988									match map.next_value::<DeserializeWith>() {
5989										Ok(deserialize_with) => deserialize_with.0,
5990										Err(err) => {
5991											return Err(err);
5992										}
5993									}
5994								});
5995							}
5996							Field::VehicleSpecialUsage => {
5997								if r#vehicle_special_usage_property.is_some() {
5998									return Err(<A::Error as de::Error>::duplicate_field(
5999										"vehicleSpecialUsage",
6000									));
6001								}
6002								r#vehicle_special_usage_property = Some({
6003									struct DeserializeWith(Vec<VehicleSpecialUsageProperty>);
6004									impl<'de> Deserialize<'de> for DeserializeWith {
6005										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6006										where
6007											D: Deserializer<'de>,
6008										{
6009											Ok(DeserializeWith(serde_with::As::<
6010												serde_with::OneOrMany<serde_with::Same>,
6011											>::deserialize(deserializer)?))
6012										}
6013									}
6014									match map.next_value::<DeserializeWith>() {
6015										Ok(deserialize_with) => deserialize_with.0,
6016										Err(err) => {
6017											return Err(err);
6018										}
6019									}
6020								});
6021							}
6022							Field::VehicleTransmission => {
6023								if r#vehicle_transmission_property.is_some() {
6024									return Err(<A::Error as de::Error>::duplicate_field(
6025										"vehicleTransmission",
6026									));
6027								}
6028								r#vehicle_transmission_property = Some({
6029									struct DeserializeWith(Vec<VehicleTransmissionProperty>);
6030									impl<'de> Deserialize<'de> for DeserializeWith {
6031										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6032										where
6033											D: Deserializer<'de>,
6034										{
6035											Ok(DeserializeWith(serde_with::As::<
6036												serde_with::OneOrMany<serde_with::Same>,
6037											>::deserialize(deserializer)?))
6038										}
6039									}
6040									match map.next_value::<DeserializeWith>() {
6041										Ok(deserialize_with) => deserialize_with.0,
6042										Err(err) => {
6043											return Err(err);
6044										}
6045									}
6046								});
6047							}
6048							Field::WeightTotal => {
6049								if r#weight_total_property.is_some() {
6050									return Err(<A::Error as de::Error>::duplicate_field(
6051										"weightTotal",
6052									));
6053								}
6054								r#weight_total_property = Some({
6055									struct DeserializeWith(Vec<WeightTotalProperty>);
6056									impl<'de> Deserialize<'de> for DeserializeWith {
6057										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6058										where
6059											D: Deserializer<'de>,
6060										{
6061											Ok(DeserializeWith(serde_with::As::<
6062												serde_with::OneOrMany<serde_with::Same>,
6063											>::deserialize(deserializer)?))
6064										}
6065									}
6066									match map.next_value::<DeserializeWith>() {
6067										Ok(deserialize_with) => deserialize_with.0,
6068										Err(err) => {
6069											return Err(err);
6070										}
6071									}
6072								});
6073							}
6074							Field::Wheelbase => {
6075								if r#wheelbase_property.is_some() {
6076									return Err(<A::Error as de::Error>::duplicate_field(
6077										"wheelbase",
6078									));
6079								}
6080								r#wheelbase_property = Some({
6081									struct DeserializeWith(Vec<WheelbaseProperty>);
6082									impl<'de> Deserialize<'de> for DeserializeWith {
6083										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6084										where
6085											D: Deserializer<'de>,
6086										{
6087											Ok(DeserializeWith(serde_with::As::<
6088												serde_with::OneOrMany<serde_with::Same>,
6089											>::deserialize(deserializer)?))
6090										}
6091									}
6092									match map.next_value::<DeserializeWith>() {
6093										Ok(deserialize_with) => deserialize_with.0,
6094										Err(err) => {
6095											return Err(err);
6096										}
6097									}
6098								});
6099							}
6100							Field::Ignore => {
6101								let _ = map.next_value::<de::IgnoredAny>()?;
6102							}
6103						}
6104					}
6105					Ok(Motorcycle {
6106						r#additional_property: r#additional_property_property.unwrap_or_default(),
6107						r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
6108						r#asin: r#asin_property.unwrap_or_default(),
6109						r#audience: r#audience_property.unwrap_or_default(),
6110						r#award: r#award_property.unwrap_or_default(),
6111						r#awards: r#awards_property.unwrap_or_default(),
6112						r#brand: r#brand_property.unwrap_or_default(),
6113						r#category: r#category_property.unwrap_or_default(),
6114						r#color: r#color_property.unwrap_or_default(),
6115						r#country_of_assembly: r#country_of_assembly_property.unwrap_or_default(),
6116						r#country_of_last_processing: r#country_of_last_processing_property
6117							.unwrap_or_default(),
6118						r#country_of_origin: r#country_of_origin_property.unwrap_or_default(),
6119						r#depth: r#depth_property.unwrap_or_default(),
6120						r#funding: r#funding_property.unwrap_or_default(),
6121						r#gtin: r#gtin_property.unwrap_or_default(),
6122						r#gtin_12: r#gtin_12_property.unwrap_or_default(),
6123						r#gtin_13: r#gtin_13_property.unwrap_or_default(),
6124						r#gtin_14: r#gtin_14_property.unwrap_or_default(),
6125						r#gtin_8: r#gtin_8_property.unwrap_or_default(),
6126						r#has_adult_consideration: r#has_adult_consideration_property
6127							.unwrap_or_default(),
6128						r#has_energy_consumption_details: r#has_energy_consumption_details_property
6129							.unwrap_or_default(),
6130						r#has_measurement: r#has_measurement_property.unwrap_or_default(),
6131						r#has_merchant_return_policy: r#has_merchant_return_policy_property
6132							.unwrap_or_default(),
6133						r#has_product_return_policy: r#has_product_return_policy_property
6134							.unwrap_or_default(),
6135						r#height: r#height_property.unwrap_or_default(),
6136						r#in_product_group_with_id: r#in_product_group_with_id_property
6137							.unwrap_or_default(),
6138						r#is_accessory_or_spare_part_for: r#is_accessory_or_spare_part_for_property
6139							.unwrap_or_default(),
6140						r#is_consumable_for: r#is_consumable_for_property.unwrap_or_default(),
6141						r#is_family_friendly: r#is_family_friendly_property.unwrap_or_default(),
6142						r#is_related_to: r#is_related_to_property.unwrap_or_default(),
6143						r#is_similar_to: r#is_similar_to_property.unwrap_or_default(),
6144						r#is_variant_of: r#is_variant_of_property.unwrap_or_default(),
6145						r#item_condition: r#item_condition_property.unwrap_or_default(),
6146						r#keywords: r#keywords_property.unwrap_or_default(),
6147						r#logo: r#logo_property.unwrap_or_default(),
6148						r#manufacturer: r#manufacturer_property.unwrap_or_default(),
6149						r#material: r#material_property.unwrap_or_default(),
6150						r#mobile_url: r#mobile_url_property.unwrap_or_default(),
6151						r#model: r#model_property.unwrap_or_default(),
6152						r#mpn: r#mpn_property.unwrap_or_default(),
6153						r#negative_notes: r#negative_notes_property.unwrap_or_default(),
6154						r#nsn: r#nsn_property.unwrap_or_default(),
6155						r#offers: r#offers_property.unwrap_or_default(),
6156						r#pattern: r#pattern_property.unwrap_or_default(),
6157						r#positive_notes: r#positive_notes_property.unwrap_or_default(),
6158						r#product_id: r#product_id_property.unwrap_or_default(),
6159						r#production_date: r#production_date_property.unwrap_or_default(),
6160						r#purchase_date: r#purchase_date_property.unwrap_or_default(),
6161						r#release_date: r#release_date_property.unwrap_or_default(),
6162						r#review: r#review_property.unwrap_or_default(),
6163						r#reviews: r#reviews_property.unwrap_or_default(),
6164						r#size: r#size_property.unwrap_or_default(),
6165						r#sku: r#sku_property.unwrap_or_default(),
6166						r#slogan: r#slogan_property.unwrap_or_default(),
6167						r#weight: r#weight_property.unwrap_or_default(),
6168						r#width: r#width_property.unwrap_or_default(),
6169						r#additional_type: r#additional_type_property.unwrap_or_default(),
6170						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
6171						r#description: r#description_property.unwrap_or_default(),
6172						r#disambiguating_description: r#disambiguating_description_property
6173							.unwrap_or_default(),
6174						r#identifier: r#identifier_property.unwrap_or_default(),
6175						r#image: r#image_property.unwrap_or_default(),
6176						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
6177						r#name: r#name_property.unwrap_or_default(),
6178						r#potential_action: r#potential_action_property.unwrap_or_default(),
6179						r#same_as: r#same_as_property.unwrap_or_default(),
6180						r#subject_of: r#subject_of_property.unwrap_or_default(),
6181						r#url: r#url_property.unwrap_or_default(),
6182						r#acceleration_time: r#acceleration_time_property.unwrap_or_default(),
6183						r#body_type: r#body_type_property.unwrap_or_default(),
6184						r#call_sign: r#call_sign_property.unwrap_or_default(),
6185						r#cargo_volume: r#cargo_volume_property.unwrap_or_default(),
6186						r#date_vehicle_first_registered: r#date_vehicle_first_registered_property
6187							.unwrap_or_default(),
6188						r#drive_wheel_configuration: r#drive_wheel_configuration_property
6189							.unwrap_or_default(),
6190						r#emissions_co_2: r#emissions_co_2_property.unwrap_or_default(),
6191						r#fuel_capacity: r#fuel_capacity_property.unwrap_or_default(),
6192						r#fuel_consumption: r#fuel_consumption_property.unwrap_or_default(),
6193						r#fuel_efficiency: r#fuel_efficiency_property.unwrap_or_default(),
6194						r#fuel_type: r#fuel_type_property.unwrap_or_default(),
6195						r#known_vehicle_damages: r#known_vehicle_damages_property
6196							.unwrap_or_default(),
6197						r#meets_emission_standard: r#meets_emission_standard_property
6198							.unwrap_or_default(),
6199						r#mileage_from_odometer: r#mileage_from_odometer_property
6200							.unwrap_or_default(),
6201						r#model_date: r#model_date_property.unwrap_or_default(),
6202						r#number_of_airbags: r#number_of_airbags_property.unwrap_or_default(),
6203						r#number_of_axles: r#number_of_axles_property.unwrap_or_default(),
6204						r#number_of_doors: r#number_of_doors_property.unwrap_or_default(),
6205						r#number_of_forward_gears: r#number_of_forward_gears_property
6206							.unwrap_or_default(),
6207						r#number_of_previous_owners: r#number_of_previous_owners_property
6208							.unwrap_or_default(),
6209						r#payload: r#payload_property.unwrap_or_default(),
6210						r#seating_capacity: r#seating_capacity_property.unwrap_or_default(),
6211						r#speed: r#speed_property.unwrap_or_default(),
6212						r#steering_position: r#steering_position_property.unwrap_or_default(),
6213						r#stupid_property: r#stupid_property_property.unwrap_or_default(),
6214						r#tongue_weight: r#tongue_weight_property.unwrap_or_default(),
6215						r#trailer_weight: r#trailer_weight_property.unwrap_or_default(),
6216						r#vehicle_configuration: r#vehicle_configuration_property
6217							.unwrap_or_default(),
6218						r#vehicle_engine: r#vehicle_engine_property.unwrap_or_default(),
6219						r#vehicle_identification_number: r#vehicle_identification_number_property
6220							.unwrap_or_default(),
6221						r#vehicle_interior_color: r#vehicle_interior_color_property
6222							.unwrap_or_default(),
6223						r#vehicle_interior_type: r#vehicle_interior_type_property
6224							.unwrap_or_default(),
6225						r#vehicle_model_date: r#vehicle_model_date_property.unwrap_or_default(),
6226						r#vehicle_seating_capacity: r#vehicle_seating_capacity_property
6227							.unwrap_or_default(),
6228						r#vehicle_special_usage: r#vehicle_special_usage_property
6229							.unwrap_or_default(),
6230						r#vehicle_transmission: r#vehicle_transmission_property.unwrap_or_default(),
6231						r#weight_total: r#weight_total_property.unwrap_or_default(),
6232						r#wheelbase: r#wheelbase_property.unwrap_or_default(),
6233					})
6234				}
6235			}
6236			const FIELDS: &[&str] = &[
6237				"additionalProperty",
6238				"aggregateRating",
6239				"asin",
6240				"audience",
6241				"award",
6242				"awards",
6243				"brand",
6244				"category",
6245				"color",
6246				"countryOfAssembly",
6247				"countryOfLastProcessing",
6248				"countryOfOrigin",
6249				"depth",
6250				"funding",
6251				"gtin",
6252				"gtin12",
6253				"gtin13",
6254				"gtin14",
6255				"gtin8",
6256				"hasAdultConsideration",
6257				"hasEnergyConsumptionDetails",
6258				"hasMeasurement",
6259				"hasMerchantReturnPolicy",
6260				"hasProductReturnPolicy",
6261				"height",
6262				"inProductGroupWithID",
6263				"isAccessoryOrSparePartFor",
6264				"isConsumableFor",
6265				"isFamilyFriendly",
6266				"isRelatedTo",
6267				"isSimilarTo",
6268				"isVariantOf",
6269				"itemCondition",
6270				"keywords",
6271				"logo",
6272				"manufacturer",
6273				"material",
6274				"mobileUrl",
6275				"model",
6276				"mpn",
6277				"negativeNotes",
6278				"nsn",
6279				"offers",
6280				"pattern",
6281				"positiveNotes",
6282				"productID",
6283				"productionDate",
6284				"purchaseDate",
6285				"releaseDate",
6286				"review",
6287				"reviews",
6288				"size",
6289				"sku",
6290				"slogan",
6291				"weight",
6292				"width",
6293				"additionalType",
6294				"alternateName",
6295				"description",
6296				"disambiguatingDescription",
6297				"identifier",
6298				"image",
6299				"mainEntityOfPage",
6300				"name",
6301				"potentialAction",
6302				"sameAs",
6303				"subjectOf",
6304				"url",
6305				"accelerationTime",
6306				"bodyType",
6307				"callSign",
6308				"cargoVolume",
6309				"dateVehicleFirstRegistered",
6310				"driveWheelConfiguration",
6311				"emissionsCO2",
6312				"fuelCapacity",
6313				"fuelConsumption",
6314				"fuelEfficiency",
6315				"fuelType",
6316				"knownVehicleDamages",
6317				"meetsEmissionStandard",
6318				"mileageFromOdometer",
6319				"modelDate",
6320				"numberOfAirbags",
6321				"numberOfAxles",
6322				"numberOfDoors",
6323				"numberOfForwardGears",
6324				"numberOfPreviousOwners",
6325				"payload",
6326				"seatingCapacity",
6327				"speed",
6328				"steeringPosition",
6329				"stupidProperty",
6330				"tongueWeight",
6331				"trailerWeight",
6332				"vehicleConfiguration",
6333				"vehicleEngine",
6334				"vehicleIdentificationNumber",
6335				"vehicleInteriorColor",
6336				"vehicleInteriorType",
6337				"vehicleModelDate",
6338				"vehicleSeatingCapacity",
6339				"vehicleSpecialUsage",
6340				"vehicleTransmission",
6341				"weightTotal",
6342				"wheelbase",
6343			];
6344			deserializer.deserialize_struct("Motorcycle", FIELDS, ClassVisitor)
6345		}
6346	}
6347}
schema_org_types/schemas/classes/motorcycle.rs

schema_org_types/schemas/classes/
motorcycle.rs
