schema_org_types/schemas/classes/
unit_price_specification.rs

1use super::*;
2/// <https://schema.org/UnitPriceSpecification>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct UnitPriceSpecification {
6	/// <https://schema.org/billingDuration>
7	pub r#billing_duration: Vec<BillingDurationProperty>,
8	/// <https://schema.org/billingIncrement>
9	pub r#billing_increment: Vec<BillingIncrementProperty>,
10	/// <https://schema.org/billingStart>
11	pub r#billing_start: Vec<BillingStartProperty>,
12	/// <https://schema.org/priceComponentType>
13	pub r#price_component_type: Vec<PriceComponentTypeProperty>,
14	/// <https://schema.org/priceType>
15	pub r#price_type: Vec<PriceTypeProperty>,
16	/// <https://schema.org/referenceQuantity>
17	pub r#reference_quantity: Vec<ReferenceQuantityProperty>,
18	/// <https://schema.org/unitCode>
19	pub r#unit_code: Vec<UnitCodeProperty>,
20	/// <https://schema.org/unitText>
21	pub r#unit_text: Vec<UnitTextProperty>,
22	/// <https://schema.org/eligibleQuantity>
23	pub r#eligible_quantity: Vec<EligibleQuantityProperty>,
24	/// <https://schema.org/eligibleTransactionVolume>
25	pub r#eligible_transaction_volume: Vec<EligibleTransactionVolumeProperty>,
26	/// <https://schema.org/maxPrice>
27	pub r#max_price: Vec<MaxPriceProperty>,
28	/// <https://schema.org/minPrice>
29	pub r#min_price: Vec<MinPriceProperty>,
30	/// <https://schema.org/price>
31	pub r#price: Vec<PriceProperty>,
32	/// <https://schema.org/priceCurrency>
33	pub r#price_currency: Vec<PriceCurrencyProperty>,
34	/// <https://schema.org/validFrom>
35	pub r#valid_from: Vec<ValidFromProperty>,
36	/// <https://schema.org/validThrough>
37	pub r#valid_through: Vec<ValidThroughProperty>,
38	/// <https://schema.org/valueAddedTaxIncluded>
39	pub r#value_added_tax_included: Vec<ValueAddedTaxIncludedProperty>,
40	/// <https://schema.org/additionalType>
41	pub r#additional_type: Vec<AdditionalTypeProperty>,
42	/// <https://schema.org/alternateName>
43	pub r#alternate_name: Vec<AlternateNameProperty>,
44	/// <https://schema.org/description>
45	pub r#description: Vec<DescriptionProperty>,
46	/// <https://schema.org/disambiguatingDescription>
47	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
48	/// <https://schema.org/identifier>
49	pub r#identifier: Vec<IdentifierProperty>,
50	/// <https://schema.org/image>
51	pub r#image: Vec<ImageProperty>,
52	/// <https://schema.org/mainEntityOfPage>
53	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
54	/// <https://schema.org/name>
55	pub r#name: Vec<NameProperty>,
56	/// <https://schema.org/potentialAction>
57	pub r#potential_action: Vec<PotentialActionProperty>,
58	/// <https://schema.org/sameAs>
59	pub r#same_as: Vec<SameAsProperty>,
60	/// <https://schema.org/subjectOf>
61	pub r#subject_of: Vec<SubjectOfProperty>,
62	/// <https://schema.org/url>
63	pub r#url: Vec<UrlProperty>,
64}
65/// This trait is for properties from <https://schema.org/UnitPriceSpecification>.
66pub trait UnitPriceSpecificationTrait {
67	/// Get <https://schema.org/billingDuration> from [`Self`] as borrowed slice.
68	fn get_billing_duration(&self) -> &[BillingDurationProperty];
69	/// Take <https://schema.org/billingDuration> from [`Self`] as owned vector.
70	fn take_billing_duration(&mut self) -> Vec<BillingDurationProperty>;
71	/// Get <https://schema.org/billingIncrement> from [`Self`] as borrowed slice.
72	fn get_billing_increment(&self) -> &[BillingIncrementProperty];
73	/// Take <https://schema.org/billingIncrement> from [`Self`] as owned vector.
74	fn take_billing_increment(&mut self) -> Vec<BillingIncrementProperty>;
75	/// Get <https://schema.org/billingStart> from [`Self`] as borrowed slice.
76	fn get_billing_start(&self) -> &[BillingStartProperty];
77	/// Take <https://schema.org/billingStart> from [`Self`] as owned vector.
78	fn take_billing_start(&mut self) -> Vec<BillingStartProperty>;
79	/// Get <https://schema.org/priceComponentType> from [`Self`] as borrowed slice.
80	fn get_price_component_type(&self) -> &[PriceComponentTypeProperty];
81	/// Take <https://schema.org/priceComponentType> from [`Self`] as owned vector.
82	fn take_price_component_type(&mut self) -> Vec<PriceComponentTypeProperty>;
83	/// Get <https://schema.org/priceType> from [`Self`] as borrowed slice.
84	fn get_price_type(&self) -> &[PriceTypeProperty];
85	/// Take <https://schema.org/priceType> from [`Self`] as owned vector.
86	fn take_price_type(&mut self) -> Vec<PriceTypeProperty>;
87	/// Get <https://schema.org/referenceQuantity> from [`Self`] as borrowed slice.
88	fn get_reference_quantity(&self) -> &[ReferenceQuantityProperty];
89	/// Take <https://schema.org/referenceQuantity> from [`Self`] as owned vector.
90	fn take_reference_quantity(&mut self) -> Vec<ReferenceQuantityProperty>;
91	/// Get <https://schema.org/unitCode> from [`Self`] as borrowed slice.
92	fn get_unit_code(&self) -> &[UnitCodeProperty];
93	/// Take <https://schema.org/unitCode> from [`Self`] as owned vector.
94	fn take_unit_code(&mut self) -> Vec<UnitCodeProperty>;
95	/// Get <https://schema.org/unitText> from [`Self`] as borrowed slice.
96	fn get_unit_text(&self) -> &[UnitTextProperty];
97	/// Take <https://schema.org/unitText> from [`Self`] as owned vector.
98	fn take_unit_text(&mut self) -> Vec<UnitTextProperty>;
99}
100impl UnitPriceSpecificationTrait for UnitPriceSpecification {
101	fn get_billing_duration(&self) -> &[BillingDurationProperty] {
102		self.r#billing_duration.as_slice()
103	}
104	fn take_billing_duration(&mut self) -> Vec<BillingDurationProperty> {
105		std::mem::take(&mut self.r#billing_duration)
106	}
107	fn get_billing_increment(&self) -> &[BillingIncrementProperty] {
108		self.r#billing_increment.as_slice()
109	}
110	fn take_billing_increment(&mut self) -> Vec<BillingIncrementProperty> {
111		std::mem::take(&mut self.r#billing_increment)
112	}
113	fn get_billing_start(&self) -> &[BillingStartProperty] {
114		self.r#billing_start.as_slice()
115	}
116	fn take_billing_start(&mut self) -> Vec<BillingStartProperty> {
117		std::mem::take(&mut self.r#billing_start)
118	}
119	fn get_price_component_type(&self) -> &[PriceComponentTypeProperty] {
120		self.r#price_component_type.as_slice()
121	}
122	fn take_price_component_type(&mut self) -> Vec<PriceComponentTypeProperty> {
123		std::mem::take(&mut self.r#price_component_type)
124	}
125	fn get_price_type(&self) -> &[PriceTypeProperty] {
126		self.r#price_type.as_slice()
127	}
128	fn take_price_type(&mut self) -> Vec<PriceTypeProperty> {
129		std::mem::take(&mut self.r#price_type)
130	}
131	fn get_reference_quantity(&self) -> &[ReferenceQuantityProperty] {
132		self.r#reference_quantity.as_slice()
133	}
134	fn take_reference_quantity(&mut self) -> Vec<ReferenceQuantityProperty> {
135		std::mem::take(&mut self.r#reference_quantity)
136	}
137	fn get_unit_code(&self) -> &[UnitCodeProperty] {
138		self.r#unit_code.as_slice()
139	}
140	fn take_unit_code(&mut self) -> Vec<UnitCodeProperty> {
141		std::mem::take(&mut self.r#unit_code)
142	}
143	fn get_unit_text(&self) -> &[UnitTextProperty] {
144		self.r#unit_text.as_slice()
145	}
146	fn take_unit_text(&mut self) -> Vec<UnitTextProperty> {
147		std::mem::take(&mut self.r#unit_text)
148	}
149}
150impl PriceSpecificationTrait for UnitPriceSpecification {
151	fn get_eligible_quantity(&self) -> &[EligibleQuantityProperty] {
152		self.r#eligible_quantity.as_slice()
153	}
154	fn take_eligible_quantity(&mut self) -> Vec<EligibleQuantityProperty> {
155		std::mem::take(&mut self.r#eligible_quantity)
156	}
157	fn get_eligible_transaction_volume(&self) -> &[EligibleTransactionVolumeProperty] {
158		self.r#eligible_transaction_volume.as_slice()
159	}
160	fn take_eligible_transaction_volume(&mut self) -> Vec<EligibleTransactionVolumeProperty> {
161		std::mem::take(&mut self.r#eligible_transaction_volume)
162	}
163	fn get_max_price(&self) -> &[MaxPriceProperty] {
164		self.r#max_price.as_slice()
165	}
166	fn take_max_price(&mut self) -> Vec<MaxPriceProperty> {
167		std::mem::take(&mut self.r#max_price)
168	}
169	fn get_min_price(&self) -> &[MinPriceProperty] {
170		self.r#min_price.as_slice()
171	}
172	fn take_min_price(&mut self) -> Vec<MinPriceProperty> {
173		std::mem::take(&mut self.r#min_price)
174	}
175	fn get_price(&self) -> &[PriceProperty] {
176		self.r#price.as_slice()
177	}
178	fn take_price(&mut self) -> Vec<PriceProperty> {
179		std::mem::take(&mut self.r#price)
180	}
181	fn get_price_currency(&self) -> &[PriceCurrencyProperty] {
182		self.r#price_currency.as_slice()
183	}
184	fn take_price_currency(&mut self) -> Vec<PriceCurrencyProperty> {
185		std::mem::take(&mut self.r#price_currency)
186	}
187	fn get_valid_from(&self) -> &[ValidFromProperty] {
188		self.r#valid_from.as_slice()
189	}
190	fn take_valid_from(&mut self) -> Vec<ValidFromProperty> {
191		std::mem::take(&mut self.r#valid_from)
192	}
193	fn get_valid_through(&self) -> &[ValidThroughProperty] {
194		self.r#valid_through.as_slice()
195	}
196	fn take_valid_through(&mut self) -> Vec<ValidThroughProperty> {
197		std::mem::take(&mut self.r#valid_through)
198	}
199	fn get_value_added_tax_included(&self) -> &[ValueAddedTaxIncludedProperty] {
200		self.r#value_added_tax_included.as_slice()
201	}
202	fn take_value_added_tax_included(&mut self) -> Vec<ValueAddedTaxIncludedProperty> {
203		std::mem::take(&mut self.r#value_added_tax_included)
204	}
205}
206impl StructuredValueTrait for UnitPriceSpecification {}
207impl ThingTrait for UnitPriceSpecification {
208	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
209		self.r#additional_type.as_slice()
210	}
211	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
212		std::mem::take(&mut self.r#additional_type)
213	}
214	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
215		self.r#alternate_name.as_slice()
216	}
217	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
218		std::mem::take(&mut self.r#alternate_name)
219	}
220	fn get_description(&self) -> &[DescriptionProperty] {
221		self.r#description.as_slice()
222	}
223	fn take_description(&mut self) -> Vec<DescriptionProperty> {
224		std::mem::take(&mut self.r#description)
225	}
226	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
227		self.r#disambiguating_description.as_slice()
228	}
229	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
230		std::mem::take(&mut self.r#disambiguating_description)
231	}
232	fn get_identifier(&self) -> &[IdentifierProperty] {
233		self.r#identifier.as_slice()
234	}
235	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
236		std::mem::take(&mut self.r#identifier)
237	}
238	fn get_image(&self) -> &[ImageProperty] {
239		self.r#image.as_slice()
240	}
241	fn take_image(&mut self) -> Vec<ImageProperty> {
242		std::mem::take(&mut self.r#image)
243	}
244	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
245		self.r#main_entity_of_page.as_slice()
246	}
247	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
248		std::mem::take(&mut self.r#main_entity_of_page)
249	}
250	fn get_name(&self) -> &[NameProperty] {
251		self.r#name.as_slice()
252	}
253	fn take_name(&mut self) -> Vec<NameProperty> {
254		std::mem::take(&mut self.r#name)
255	}
256	fn get_potential_action(&self) -> &[PotentialActionProperty] {
257		self.r#potential_action.as_slice()
258	}
259	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
260		std::mem::take(&mut self.r#potential_action)
261	}
262	fn get_same_as(&self) -> &[SameAsProperty] {
263		self.r#same_as.as_slice()
264	}
265	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
266		std::mem::take(&mut self.r#same_as)
267	}
268	fn get_subject_of(&self) -> &[SubjectOfProperty] {
269		self.r#subject_of.as_slice()
270	}
271	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
272		std::mem::take(&mut self.r#subject_of)
273	}
274	fn get_url(&self) -> &[UrlProperty] {
275		self.r#url.as_slice()
276	}
277	fn take_url(&mut self) -> Vec<UrlProperty> {
278		std::mem::take(&mut self.r#url)
279	}
280}
281#[cfg(feature = "serde")]
282mod serde {
283	use std::{fmt, fmt::Formatter};
284
285	use ::serde::{
286		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
287	};
288
289	use super::*;
290	impl Serialize for UnitPriceSpecification {
291		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
292		where
293			S: Serializer,
294		{
295			let len: usize = [
296				!Vec::is_empty(&self.r#billing_duration) as usize,
297				!Vec::is_empty(&self.r#billing_increment) as usize,
298				!Vec::is_empty(&self.r#billing_start) as usize,
299				!Vec::is_empty(&self.r#price_component_type) as usize,
300				!Vec::is_empty(&self.r#price_type) as usize,
301				!Vec::is_empty(&self.r#reference_quantity) as usize,
302				!Vec::is_empty(&self.r#unit_code) as usize,
303				!Vec::is_empty(&self.r#unit_text) as usize,
304				!Vec::is_empty(&self.r#eligible_quantity) as usize,
305				!Vec::is_empty(&self.r#eligible_transaction_volume) as usize,
306				!Vec::is_empty(&self.r#max_price) as usize,
307				!Vec::is_empty(&self.r#min_price) as usize,
308				!Vec::is_empty(&self.r#price) as usize,
309				!Vec::is_empty(&self.r#price_currency) as usize,
310				!Vec::is_empty(&self.r#valid_from) as usize,
311				!Vec::is_empty(&self.r#valid_through) as usize,
312				!Vec::is_empty(&self.r#value_added_tax_included) as usize,
313				!Vec::is_empty(&self.r#additional_type) as usize,
314				!Vec::is_empty(&self.r#alternate_name) as usize,
315				!Vec::is_empty(&self.r#description) as usize,
316				!Vec::is_empty(&self.r#disambiguating_description) as usize,
317				!Vec::is_empty(&self.r#identifier) as usize,
318				!Vec::is_empty(&self.r#image) as usize,
319				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
320				!Vec::is_empty(&self.r#name) as usize,
321				!Vec::is_empty(&self.r#potential_action) as usize,
322				!Vec::is_empty(&self.r#same_as) as usize,
323				!Vec::is_empty(&self.r#subject_of) as usize,
324				!Vec::is_empty(&self.r#url) as usize,
325			]
326			.iter()
327			.sum();
328			let mut serialize_struct =
329				Serializer::serialize_struct(serializer, "UnitPriceSpecification", len)?;
330			if !Vec::is_empty(&self.r#billing_duration) {
331				serialize_struct.serialize_field("billingDuration", {
332					struct SerializeWith<'a>(&'a Vec<BillingDurationProperty>);
333					impl<'a> Serialize for SerializeWith<'a> {
334						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
335						where
336							S: Serializer,
337						{
338							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
339								self.0, serializer,
340							)
341						}
342					}
343					&SerializeWith(&self.r#billing_duration)
344				})?;
345			} else {
346				serialize_struct.skip_field("billingDuration")?;
347			}
348			if !Vec::is_empty(&self.r#billing_increment) {
349				serialize_struct.serialize_field("billingIncrement", {
350					struct SerializeWith<'a>(&'a Vec<BillingIncrementProperty>);
351					impl<'a> Serialize for SerializeWith<'a> {
352						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
353						where
354							S: Serializer,
355						{
356							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
357								self.0, serializer,
358							)
359						}
360					}
361					&SerializeWith(&self.r#billing_increment)
362				})?;
363			} else {
364				serialize_struct.skip_field("billingIncrement")?;
365			}
366			if !Vec::is_empty(&self.r#billing_start) {
367				serialize_struct.serialize_field("billingStart", {
368					struct SerializeWith<'a>(&'a Vec<BillingStartProperty>);
369					impl<'a> Serialize for SerializeWith<'a> {
370						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
371						where
372							S: Serializer,
373						{
374							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
375								self.0, serializer,
376							)
377						}
378					}
379					&SerializeWith(&self.r#billing_start)
380				})?;
381			} else {
382				serialize_struct.skip_field("billingStart")?;
383			}
384			if !Vec::is_empty(&self.r#price_component_type) {
385				serialize_struct.serialize_field("priceComponentType", {
386					struct SerializeWith<'a>(&'a Vec<PriceComponentTypeProperty>);
387					impl<'a> Serialize for SerializeWith<'a> {
388						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
389						where
390							S: Serializer,
391						{
392							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
393								self.0, serializer,
394							)
395						}
396					}
397					&SerializeWith(&self.r#price_component_type)
398				})?;
399			} else {
400				serialize_struct.skip_field("priceComponentType")?;
401			}
402			if !Vec::is_empty(&self.r#price_type) {
403				serialize_struct.serialize_field("priceType", {
404					struct SerializeWith<'a>(&'a Vec<PriceTypeProperty>);
405					impl<'a> Serialize for SerializeWith<'a> {
406						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
407						where
408							S: Serializer,
409						{
410							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
411								self.0, serializer,
412							)
413						}
414					}
415					&SerializeWith(&self.r#price_type)
416				})?;
417			} else {
418				serialize_struct.skip_field("priceType")?;
419			}
420			if !Vec::is_empty(&self.r#reference_quantity) {
421				serialize_struct.serialize_field("referenceQuantity", {
422					struct SerializeWith<'a>(&'a Vec<ReferenceQuantityProperty>);
423					impl<'a> Serialize for SerializeWith<'a> {
424						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
425						where
426							S: Serializer,
427						{
428							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
429								self.0, serializer,
430							)
431						}
432					}
433					&SerializeWith(&self.r#reference_quantity)
434				})?;
435			} else {
436				serialize_struct.skip_field("referenceQuantity")?;
437			}
438			if !Vec::is_empty(&self.r#unit_code) {
439				serialize_struct.serialize_field("unitCode", {
440					struct SerializeWith<'a>(&'a Vec<UnitCodeProperty>);
441					impl<'a> Serialize for SerializeWith<'a> {
442						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
443						where
444							S: Serializer,
445						{
446							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
447								self.0, serializer,
448							)
449						}
450					}
451					&SerializeWith(&self.r#unit_code)
452				})?;
453			} else {
454				serialize_struct.skip_field("unitCode")?;
455			}
456			if !Vec::is_empty(&self.r#unit_text) {
457				serialize_struct.serialize_field("unitText", {
458					struct SerializeWith<'a>(&'a Vec<UnitTextProperty>);
459					impl<'a> Serialize for SerializeWith<'a> {
460						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
461						where
462							S: Serializer,
463						{
464							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
465								self.0, serializer,
466							)
467						}
468					}
469					&SerializeWith(&self.r#unit_text)
470				})?;
471			} else {
472				serialize_struct.skip_field("unitText")?;
473			}
474			if !Vec::is_empty(&self.r#eligible_quantity) {
475				serialize_struct.serialize_field("eligibleQuantity", {
476					struct SerializeWith<'a>(&'a Vec<EligibleQuantityProperty>);
477					impl<'a> Serialize for SerializeWith<'a> {
478						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
479						where
480							S: Serializer,
481						{
482							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
483								self.0, serializer,
484							)
485						}
486					}
487					&SerializeWith(&self.r#eligible_quantity)
488				})?;
489			} else {
490				serialize_struct.skip_field("eligibleQuantity")?;
491			}
492			if !Vec::is_empty(&self.r#eligible_transaction_volume) {
493				serialize_struct.serialize_field("eligibleTransactionVolume", {
494					struct SerializeWith<'a>(&'a Vec<EligibleTransactionVolumeProperty>);
495					impl<'a> Serialize for SerializeWith<'a> {
496						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
497						where
498							S: Serializer,
499						{
500							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
501								self.0, serializer,
502							)
503						}
504					}
505					&SerializeWith(&self.r#eligible_transaction_volume)
506				})?;
507			} else {
508				serialize_struct.skip_field("eligibleTransactionVolume")?;
509			}
510			if !Vec::is_empty(&self.r#max_price) {
511				serialize_struct.serialize_field("maxPrice", {
512					struct SerializeWith<'a>(&'a Vec<MaxPriceProperty>);
513					impl<'a> Serialize for SerializeWith<'a> {
514						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
515						where
516							S: Serializer,
517						{
518							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
519								self.0, serializer,
520							)
521						}
522					}
523					&SerializeWith(&self.r#max_price)
524				})?;
525			} else {
526				serialize_struct.skip_field("maxPrice")?;
527			}
528			if !Vec::is_empty(&self.r#min_price) {
529				serialize_struct.serialize_field("minPrice", {
530					struct SerializeWith<'a>(&'a Vec<MinPriceProperty>);
531					impl<'a> Serialize for SerializeWith<'a> {
532						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
533						where
534							S: Serializer,
535						{
536							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
537								self.0, serializer,
538							)
539						}
540					}
541					&SerializeWith(&self.r#min_price)
542				})?;
543			} else {
544				serialize_struct.skip_field("minPrice")?;
545			}
546			if !Vec::is_empty(&self.r#price) {
547				serialize_struct.serialize_field("price", {
548					struct SerializeWith<'a>(&'a Vec<PriceProperty>);
549					impl<'a> Serialize for SerializeWith<'a> {
550						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
551						where
552							S: Serializer,
553						{
554							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
555								self.0, serializer,
556							)
557						}
558					}
559					&SerializeWith(&self.r#price)
560				})?;
561			} else {
562				serialize_struct.skip_field("price")?;
563			}
564			if !Vec::is_empty(&self.r#price_currency) {
565				serialize_struct.serialize_field("priceCurrency", {
566					struct SerializeWith<'a>(&'a Vec<PriceCurrencyProperty>);
567					impl<'a> Serialize for SerializeWith<'a> {
568						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
569						where
570							S: Serializer,
571						{
572							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
573								self.0, serializer,
574							)
575						}
576					}
577					&SerializeWith(&self.r#price_currency)
578				})?;
579			} else {
580				serialize_struct.skip_field("priceCurrency")?;
581			}
582			if !Vec::is_empty(&self.r#valid_from) {
583				serialize_struct.serialize_field("validFrom", {
584					struct SerializeWith<'a>(&'a Vec<ValidFromProperty>);
585					impl<'a> Serialize for SerializeWith<'a> {
586						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
587						where
588							S: Serializer,
589						{
590							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
591								self.0, serializer,
592							)
593						}
594					}
595					&SerializeWith(&self.r#valid_from)
596				})?;
597			} else {
598				serialize_struct.skip_field("validFrom")?;
599			}
600			if !Vec::is_empty(&self.r#valid_through) {
601				serialize_struct.serialize_field("validThrough", {
602					struct SerializeWith<'a>(&'a Vec<ValidThroughProperty>);
603					impl<'a> Serialize for SerializeWith<'a> {
604						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
605						where
606							S: Serializer,
607						{
608							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
609								self.0, serializer,
610							)
611						}
612					}
613					&SerializeWith(&self.r#valid_through)
614				})?;
615			} else {
616				serialize_struct.skip_field("validThrough")?;
617			}
618			if !Vec::is_empty(&self.r#value_added_tax_included) {
619				serialize_struct.serialize_field("valueAddedTaxIncluded", {
620					struct SerializeWith<'a>(&'a Vec<ValueAddedTaxIncludedProperty>);
621					impl<'a> Serialize for SerializeWith<'a> {
622						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
623						where
624							S: Serializer,
625						{
626							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
627								self.0, serializer,
628							)
629						}
630					}
631					&SerializeWith(&self.r#value_added_tax_included)
632				})?;
633			} else {
634				serialize_struct.skip_field("valueAddedTaxIncluded")?;
635			}
636			if !Vec::is_empty(&self.r#additional_type) {
637				serialize_struct.serialize_field("additionalType", {
638					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
639					impl<'a> Serialize for SerializeWith<'a> {
640						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
641						where
642							S: Serializer,
643						{
644							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
645								self.0, serializer,
646							)
647						}
648					}
649					&SerializeWith(&self.r#additional_type)
650				})?;
651			} else {
652				serialize_struct.skip_field("additionalType")?;
653			}
654			if !Vec::is_empty(&self.r#alternate_name) {
655				serialize_struct.serialize_field("alternateName", {
656					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
657					impl<'a> Serialize for SerializeWith<'a> {
658						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
659						where
660							S: Serializer,
661						{
662							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
663								self.0, serializer,
664							)
665						}
666					}
667					&SerializeWith(&self.r#alternate_name)
668				})?;
669			} else {
670				serialize_struct.skip_field("alternateName")?;
671			}
672			if !Vec::is_empty(&self.r#description) {
673				serialize_struct.serialize_field("description", {
674					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
675					impl<'a> Serialize for SerializeWith<'a> {
676						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
677						where
678							S: Serializer,
679						{
680							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
681								self.0, serializer,
682							)
683						}
684					}
685					&SerializeWith(&self.r#description)
686				})?;
687			} else {
688				serialize_struct.skip_field("description")?;
689			}
690			if !Vec::is_empty(&self.r#disambiguating_description) {
691				serialize_struct.serialize_field("disambiguatingDescription", {
692					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
693					impl<'a> Serialize for SerializeWith<'a> {
694						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
695						where
696							S: Serializer,
697						{
698							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
699								self.0, serializer,
700							)
701						}
702					}
703					&SerializeWith(&self.r#disambiguating_description)
704				})?;
705			} else {
706				serialize_struct.skip_field("disambiguatingDescription")?;
707			}
708			if !Vec::is_empty(&self.r#identifier) {
709				serialize_struct.serialize_field("identifier", {
710					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
711					impl<'a> Serialize for SerializeWith<'a> {
712						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
713						where
714							S: Serializer,
715						{
716							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
717								self.0, serializer,
718							)
719						}
720					}
721					&SerializeWith(&self.r#identifier)
722				})?;
723			} else {
724				serialize_struct.skip_field("identifier")?;
725			}
726			if !Vec::is_empty(&self.r#image) {
727				serialize_struct.serialize_field("image", {
728					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
729					impl<'a> Serialize for SerializeWith<'a> {
730						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
731						where
732							S: Serializer,
733						{
734							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
735								self.0, serializer,
736							)
737						}
738					}
739					&SerializeWith(&self.r#image)
740				})?;
741			} else {
742				serialize_struct.skip_field("image")?;
743			}
744			if !Vec::is_empty(&self.r#main_entity_of_page) {
745				serialize_struct.serialize_field("mainEntityOfPage", {
746					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
747					impl<'a> Serialize for SerializeWith<'a> {
748						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
749						where
750							S: Serializer,
751						{
752							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
753								self.0, serializer,
754							)
755						}
756					}
757					&SerializeWith(&self.r#main_entity_of_page)
758				})?;
759			} else {
760				serialize_struct.skip_field("mainEntityOfPage")?;
761			}
762			if !Vec::is_empty(&self.r#name) {
763				serialize_struct.serialize_field("name", {
764					struct SerializeWith<'a>(&'a Vec<NameProperty>);
765					impl<'a> Serialize for SerializeWith<'a> {
766						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
767						where
768							S: Serializer,
769						{
770							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
771								self.0, serializer,
772							)
773						}
774					}
775					&SerializeWith(&self.r#name)
776				})?;
777			} else {
778				serialize_struct.skip_field("name")?;
779			}
780			if !Vec::is_empty(&self.r#potential_action) {
781				serialize_struct.serialize_field("potentialAction", {
782					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
783					impl<'a> Serialize for SerializeWith<'a> {
784						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
785						where
786							S: Serializer,
787						{
788							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
789								self.0, serializer,
790							)
791						}
792					}
793					&SerializeWith(&self.r#potential_action)
794				})?;
795			} else {
796				serialize_struct.skip_field("potentialAction")?;
797			}
798			if !Vec::is_empty(&self.r#same_as) {
799				serialize_struct.serialize_field("sameAs", {
800					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
801					impl<'a> Serialize for SerializeWith<'a> {
802						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
803						where
804							S: Serializer,
805						{
806							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
807								self.0, serializer,
808							)
809						}
810					}
811					&SerializeWith(&self.r#same_as)
812				})?;
813			} else {
814				serialize_struct.skip_field("sameAs")?;
815			}
816			if !Vec::is_empty(&self.r#subject_of) {
817				serialize_struct.serialize_field("subjectOf", {
818					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
819					impl<'a> Serialize for SerializeWith<'a> {
820						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
821						where
822							S: Serializer,
823						{
824							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
825								self.0, serializer,
826							)
827						}
828					}
829					&SerializeWith(&self.r#subject_of)
830				})?;
831			} else {
832				serialize_struct.skip_field("subjectOf")?;
833			}
834			if !Vec::is_empty(&self.r#url) {
835				serialize_struct.serialize_field("url", {
836					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
837					impl<'a> Serialize for SerializeWith<'a> {
838						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
839						where
840							S: Serializer,
841						{
842							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
843								self.0, serializer,
844							)
845						}
846					}
847					&SerializeWith(&self.r#url)
848				})?;
849			} else {
850				serialize_struct.skip_field("url")?;
851			}
852			serialize_struct.end()
853		}
854	}
855	impl<'de> Deserialize<'de> for UnitPriceSpecification {
856		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
857		where
858			D: Deserializer<'de>,
859		{
860			enum Field {
861				BillingDuration,
862				BillingIncrement,
863				BillingStart,
864				PriceComponentType,
865				PriceType,
866				ReferenceQuantity,
867				UnitCode,
868				UnitText,
869				EligibleQuantity,
870				EligibleTransactionVolume,
871				MaxPrice,
872				MinPrice,
873				Price,
874				PriceCurrency,
875				ValidFrom,
876				ValidThrough,
877				ValueAddedTaxIncluded,
878				AdditionalType,
879				AlternateName,
880				Description,
881				DisambiguatingDescription,
882				Identifier,
883				Image,
884				MainEntityOfPage,
885				Name,
886				PotentialAction,
887				SameAs,
888				SubjectOf,
889				Url,
890				Ignore,
891			}
892			struct FieldVisitor;
893			impl<'de> Visitor<'de> for FieldVisitor {
894				type Value = Field;
895				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
896					formatter.write_str("field identifier")
897				}
898				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
899				where
900					E: de::Error,
901				{
902					match value {
903						"billingDuration" => Ok(Field::BillingDuration),
904						"billingIncrement" => Ok(Field::BillingIncrement),
905						"billingStart" => Ok(Field::BillingStart),
906						"priceComponentType" => Ok(Field::PriceComponentType),
907						"priceType" => Ok(Field::PriceType),
908						"referenceQuantity" => Ok(Field::ReferenceQuantity),
909						"unitCode" => Ok(Field::UnitCode),
910						"unitText" => Ok(Field::UnitText),
911						"eligibleQuantity" => Ok(Field::EligibleQuantity),
912						"eligibleTransactionVolume" => Ok(Field::EligibleTransactionVolume),
913						"maxPrice" => Ok(Field::MaxPrice),
914						"minPrice" => Ok(Field::MinPrice),
915						"price" => Ok(Field::Price),
916						"priceCurrency" => Ok(Field::PriceCurrency),
917						"validFrom" => Ok(Field::ValidFrom),
918						"validThrough" => Ok(Field::ValidThrough),
919						"valueAddedTaxIncluded" => Ok(Field::ValueAddedTaxIncluded),
920						"additionalType" => Ok(Field::AdditionalType),
921						"alternateName" => Ok(Field::AlternateName),
922						"description" => Ok(Field::Description),
923						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
924						"identifier" => Ok(Field::Identifier),
925						"image" => Ok(Field::Image),
926						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
927						"name" => Ok(Field::Name),
928						"potentialAction" => Ok(Field::PotentialAction),
929						"sameAs" => Ok(Field::SameAs),
930						"subjectOf" => Ok(Field::SubjectOf),
931						"url" => Ok(Field::Url),
932						"id" | "type" => Ok(Field::Ignore),
933						_ => Err(de::Error::unknown_field(value, FIELDS)),
934					}
935				}
936				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
937				where
938					E: de::Error,
939				{
940					match value {
941						b"billingDuration" => Ok(Field::BillingDuration),
942						b"billingIncrement" => Ok(Field::BillingIncrement),
943						b"billingStart" => Ok(Field::BillingStart),
944						b"priceComponentType" => Ok(Field::PriceComponentType),
945						b"priceType" => Ok(Field::PriceType),
946						b"referenceQuantity" => Ok(Field::ReferenceQuantity),
947						b"unitCode" => Ok(Field::UnitCode),
948						b"unitText" => Ok(Field::UnitText),
949						b"eligibleQuantity" => Ok(Field::EligibleQuantity),
950						b"eligibleTransactionVolume" => Ok(Field::EligibleTransactionVolume),
951						b"maxPrice" => Ok(Field::MaxPrice),
952						b"minPrice" => Ok(Field::MinPrice),
953						b"price" => Ok(Field::Price),
954						b"priceCurrency" => Ok(Field::PriceCurrency),
955						b"validFrom" => Ok(Field::ValidFrom),
956						b"validThrough" => Ok(Field::ValidThrough),
957						b"valueAddedTaxIncluded" => Ok(Field::ValueAddedTaxIncluded),
958						b"additionalType" => Ok(Field::AdditionalType),
959						b"alternateName" => Ok(Field::AlternateName),
960						b"description" => Ok(Field::Description),
961						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
962						b"identifier" => Ok(Field::Identifier),
963						b"image" => Ok(Field::Image),
964						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
965						b"name" => Ok(Field::Name),
966						b"potentialAction" => Ok(Field::PotentialAction),
967						b"sameAs" => Ok(Field::SameAs),
968						b"subjectOf" => Ok(Field::SubjectOf),
969						b"url" => Ok(Field::Url),
970						b"id" | b"type" => Ok(Field::Ignore),
971						_ => {
972							let value = &String::from_utf8_lossy(value);
973							Err(de::Error::unknown_field(value, FIELDS))
974						}
975					}
976				}
977			}
978			impl<'de> Deserialize<'de> for Field {
979				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
980				where
981					D: Deserializer<'de>,
982				{
983					deserializer.deserialize_identifier(FieldVisitor)
984				}
985			}
986			struct ClassVisitor;
987			impl<'de> Visitor<'de> for ClassVisitor {
988				type Value = UnitPriceSpecification;
989				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
990					formatter.write_str("schema.org schema UnitPriceSpecification")
991				}
992				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
993				where
994					A: de::MapAccess<'de>,
995				{
996					let mut r#billing_duration_property = None;
997					let mut r#billing_increment_property = None;
998					let mut r#billing_start_property = None;
999					let mut r#price_component_type_property = None;
1000					let mut r#price_type_property = None;
1001					let mut r#reference_quantity_property = None;
1002					let mut r#unit_code_property = None;
1003					let mut r#unit_text_property = None;
1004					let mut r#eligible_quantity_property = None;
1005					let mut r#eligible_transaction_volume_property = None;
1006					let mut r#max_price_property = None;
1007					let mut r#min_price_property = None;
1008					let mut r#price_property = None;
1009					let mut r#price_currency_property = None;
1010					let mut r#valid_from_property = None;
1011					let mut r#valid_through_property = None;
1012					let mut r#value_added_tax_included_property = None;
1013					let mut r#additional_type_property = None;
1014					let mut r#alternate_name_property = None;
1015					let mut r#description_property = None;
1016					let mut r#disambiguating_description_property = None;
1017					let mut r#identifier_property = None;
1018					let mut r#image_property = None;
1019					let mut r#main_entity_of_page_property = None;
1020					let mut r#name_property = None;
1021					let mut r#potential_action_property = None;
1022					let mut r#same_as_property = None;
1023					let mut r#subject_of_property = None;
1024					let mut r#url_property = None;
1025					while let Some(key) = map.next_key::<Field>()? {
1026						match key {
1027							Field::BillingDuration => {
1028								if r#billing_duration_property.is_some() {
1029									return Err(<A::Error as de::Error>::duplicate_field(
1030										"billingDuration",
1031									));
1032								}
1033								r#billing_duration_property = Some({
1034									struct DeserializeWith(Vec<BillingDurationProperty>);
1035									impl<'de> Deserialize<'de> for DeserializeWith {
1036										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1037										where
1038											D: Deserializer<'de>,
1039										{
1040											Ok(DeserializeWith(serde_with::As::<
1041												serde_with::OneOrMany<serde_with::Same>,
1042											>::deserialize(deserializer)?))
1043										}
1044									}
1045									match map.next_value::<DeserializeWith>() {
1046										Ok(deserialize_with) => deserialize_with.0,
1047										Err(err) => {
1048											return Err(err);
1049										}
1050									}
1051								});
1052							}
1053							Field::BillingIncrement => {
1054								if r#billing_increment_property.is_some() {
1055									return Err(<A::Error as de::Error>::duplicate_field(
1056										"billingIncrement",
1057									));
1058								}
1059								r#billing_increment_property = Some({
1060									struct DeserializeWith(Vec<BillingIncrementProperty>);
1061									impl<'de> Deserialize<'de> for DeserializeWith {
1062										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1063										where
1064											D: Deserializer<'de>,
1065										{
1066											Ok(DeserializeWith(serde_with::As::<
1067												serde_with::OneOrMany<serde_with::Same>,
1068											>::deserialize(deserializer)?))
1069										}
1070									}
1071									match map.next_value::<DeserializeWith>() {
1072										Ok(deserialize_with) => deserialize_with.0,
1073										Err(err) => {
1074											return Err(err);
1075										}
1076									}
1077								});
1078							}
1079							Field::BillingStart => {
1080								if r#billing_start_property.is_some() {
1081									return Err(<A::Error as de::Error>::duplicate_field(
1082										"billingStart",
1083									));
1084								}
1085								r#billing_start_property = Some({
1086									struct DeserializeWith(Vec<BillingStartProperty>);
1087									impl<'de> Deserialize<'de> for DeserializeWith {
1088										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1089										where
1090											D: Deserializer<'de>,
1091										{
1092											Ok(DeserializeWith(serde_with::As::<
1093												serde_with::OneOrMany<serde_with::Same>,
1094											>::deserialize(deserializer)?))
1095										}
1096									}
1097									match map.next_value::<DeserializeWith>() {
1098										Ok(deserialize_with) => deserialize_with.0,
1099										Err(err) => {
1100											return Err(err);
1101										}
1102									}
1103								});
1104							}
1105							Field::PriceComponentType => {
1106								if r#price_component_type_property.is_some() {
1107									return Err(<A::Error as de::Error>::duplicate_field(
1108										"priceComponentType",
1109									));
1110								}
1111								r#price_component_type_property = Some({
1112									struct DeserializeWith(Vec<PriceComponentTypeProperty>);
1113									impl<'de> Deserialize<'de> for DeserializeWith {
1114										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1115										where
1116											D: Deserializer<'de>,
1117										{
1118											Ok(DeserializeWith(serde_with::As::<
1119												serde_with::OneOrMany<serde_with::Same>,
1120											>::deserialize(deserializer)?))
1121										}
1122									}
1123									match map.next_value::<DeserializeWith>() {
1124										Ok(deserialize_with) => deserialize_with.0,
1125										Err(err) => {
1126											return Err(err);
1127										}
1128									}
1129								});
1130							}
1131							Field::PriceType => {
1132								if r#price_type_property.is_some() {
1133									return Err(<A::Error as de::Error>::duplicate_field(
1134										"priceType",
1135									));
1136								}
1137								r#price_type_property = Some({
1138									struct DeserializeWith(Vec<PriceTypeProperty>);
1139									impl<'de> Deserialize<'de> for DeserializeWith {
1140										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1141										where
1142											D: Deserializer<'de>,
1143										{
1144											Ok(DeserializeWith(serde_with::As::<
1145												serde_with::OneOrMany<serde_with::Same>,
1146											>::deserialize(deserializer)?))
1147										}
1148									}
1149									match map.next_value::<DeserializeWith>() {
1150										Ok(deserialize_with) => deserialize_with.0,
1151										Err(err) => {
1152											return Err(err);
1153										}
1154									}
1155								});
1156							}
1157							Field::ReferenceQuantity => {
1158								if r#reference_quantity_property.is_some() {
1159									return Err(<A::Error as de::Error>::duplicate_field(
1160										"referenceQuantity",
1161									));
1162								}
1163								r#reference_quantity_property = Some({
1164									struct DeserializeWith(Vec<ReferenceQuantityProperty>);
1165									impl<'de> Deserialize<'de> for DeserializeWith {
1166										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1167										where
1168											D: Deserializer<'de>,
1169										{
1170											Ok(DeserializeWith(serde_with::As::<
1171												serde_with::OneOrMany<serde_with::Same>,
1172											>::deserialize(deserializer)?))
1173										}
1174									}
1175									match map.next_value::<DeserializeWith>() {
1176										Ok(deserialize_with) => deserialize_with.0,
1177										Err(err) => {
1178											return Err(err);
1179										}
1180									}
1181								});
1182							}
1183							Field::UnitCode => {
1184								if r#unit_code_property.is_some() {
1185									return Err(<A::Error as de::Error>::duplicate_field(
1186										"unitCode",
1187									));
1188								}
1189								r#unit_code_property = Some({
1190									struct DeserializeWith(Vec<UnitCodeProperty>);
1191									impl<'de> Deserialize<'de> for DeserializeWith {
1192										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1193										where
1194											D: Deserializer<'de>,
1195										{
1196											Ok(DeserializeWith(serde_with::As::<
1197												serde_with::OneOrMany<serde_with::Same>,
1198											>::deserialize(deserializer)?))
1199										}
1200									}
1201									match map.next_value::<DeserializeWith>() {
1202										Ok(deserialize_with) => deserialize_with.0,
1203										Err(err) => {
1204											return Err(err);
1205										}
1206									}
1207								});
1208							}
1209							Field::UnitText => {
1210								if r#unit_text_property.is_some() {
1211									return Err(<A::Error as de::Error>::duplicate_field(
1212										"unitText",
1213									));
1214								}
1215								r#unit_text_property = Some({
1216									struct DeserializeWith(Vec<UnitTextProperty>);
1217									impl<'de> Deserialize<'de> for DeserializeWith {
1218										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1219										where
1220											D: Deserializer<'de>,
1221										{
1222											Ok(DeserializeWith(serde_with::As::<
1223												serde_with::OneOrMany<serde_with::Same>,
1224											>::deserialize(deserializer)?))
1225										}
1226									}
1227									match map.next_value::<DeserializeWith>() {
1228										Ok(deserialize_with) => deserialize_with.0,
1229										Err(err) => {
1230											return Err(err);
1231										}
1232									}
1233								});
1234							}
1235							Field::EligibleQuantity => {
1236								if r#eligible_quantity_property.is_some() {
1237									return Err(<A::Error as de::Error>::duplicate_field(
1238										"eligibleQuantity",
1239									));
1240								}
1241								r#eligible_quantity_property = Some({
1242									struct DeserializeWith(Vec<EligibleQuantityProperty>);
1243									impl<'de> Deserialize<'de> for DeserializeWith {
1244										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1245										where
1246											D: Deserializer<'de>,
1247										{
1248											Ok(DeserializeWith(serde_with::As::<
1249												serde_with::OneOrMany<serde_with::Same>,
1250											>::deserialize(deserializer)?))
1251										}
1252									}
1253									match map.next_value::<DeserializeWith>() {
1254										Ok(deserialize_with) => deserialize_with.0,
1255										Err(err) => {
1256											return Err(err);
1257										}
1258									}
1259								});
1260							}
1261							Field::EligibleTransactionVolume => {
1262								if r#eligible_transaction_volume_property.is_some() {
1263									return Err(<A::Error as de::Error>::duplicate_field(
1264										"eligibleTransactionVolume",
1265									));
1266								}
1267								r#eligible_transaction_volume_property = Some({
1268									struct DeserializeWith(Vec<EligibleTransactionVolumeProperty>);
1269									impl<'de> Deserialize<'de> for DeserializeWith {
1270										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1271										where
1272											D: Deserializer<'de>,
1273										{
1274											Ok(DeserializeWith(serde_with::As::<
1275												serde_with::OneOrMany<serde_with::Same>,
1276											>::deserialize(deserializer)?))
1277										}
1278									}
1279									match map.next_value::<DeserializeWith>() {
1280										Ok(deserialize_with) => deserialize_with.0,
1281										Err(err) => {
1282											return Err(err);
1283										}
1284									}
1285								});
1286							}
1287							Field::MaxPrice => {
1288								if r#max_price_property.is_some() {
1289									return Err(<A::Error as de::Error>::duplicate_field(
1290										"maxPrice",
1291									));
1292								}
1293								r#max_price_property = Some({
1294									struct DeserializeWith(Vec<MaxPriceProperty>);
1295									impl<'de> Deserialize<'de> for DeserializeWith {
1296										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1297										where
1298											D: Deserializer<'de>,
1299										{
1300											Ok(DeserializeWith(serde_with::As::<
1301												serde_with::OneOrMany<serde_with::Same>,
1302											>::deserialize(deserializer)?))
1303										}
1304									}
1305									match map.next_value::<DeserializeWith>() {
1306										Ok(deserialize_with) => deserialize_with.0,
1307										Err(err) => {
1308											return Err(err);
1309										}
1310									}
1311								});
1312							}
1313							Field::MinPrice => {
1314								if r#min_price_property.is_some() {
1315									return Err(<A::Error as de::Error>::duplicate_field(
1316										"minPrice",
1317									));
1318								}
1319								r#min_price_property = Some({
1320									struct DeserializeWith(Vec<MinPriceProperty>);
1321									impl<'de> Deserialize<'de> for DeserializeWith {
1322										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1323										where
1324											D: Deserializer<'de>,
1325										{
1326											Ok(DeserializeWith(serde_with::As::<
1327												serde_with::OneOrMany<serde_with::Same>,
1328											>::deserialize(deserializer)?))
1329										}
1330									}
1331									match map.next_value::<DeserializeWith>() {
1332										Ok(deserialize_with) => deserialize_with.0,
1333										Err(err) => {
1334											return Err(err);
1335										}
1336									}
1337								});
1338							}
1339							Field::Price => {
1340								if r#price_property.is_some() {
1341									return Err(<A::Error as de::Error>::duplicate_field("price"));
1342								}
1343								r#price_property = Some({
1344									struct DeserializeWith(Vec<PriceProperty>);
1345									impl<'de> Deserialize<'de> for DeserializeWith {
1346										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1347										where
1348											D: Deserializer<'de>,
1349										{
1350											Ok(DeserializeWith(serde_with::As::<
1351												serde_with::OneOrMany<serde_with::Same>,
1352											>::deserialize(deserializer)?))
1353										}
1354									}
1355									match map.next_value::<DeserializeWith>() {
1356										Ok(deserialize_with) => deserialize_with.0,
1357										Err(err) => {
1358											return Err(err);
1359										}
1360									}
1361								});
1362							}
1363							Field::PriceCurrency => {
1364								if r#price_currency_property.is_some() {
1365									return Err(<A::Error as de::Error>::duplicate_field(
1366										"priceCurrency",
1367									));
1368								}
1369								r#price_currency_property = Some({
1370									struct DeserializeWith(Vec<PriceCurrencyProperty>);
1371									impl<'de> Deserialize<'de> for DeserializeWith {
1372										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1373										where
1374											D: Deserializer<'de>,
1375										{
1376											Ok(DeserializeWith(serde_with::As::<
1377												serde_with::OneOrMany<serde_with::Same>,
1378											>::deserialize(deserializer)?))
1379										}
1380									}
1381									match map.next_value::<DeserializeWith>() {
1382										Ok(deserialize_with) => deserialize_with.0,
1383										Err(err) => {
1384											return Err(err);
1385										}
1386									}
1387								});
1388							}
1389							Field::ValidFrom => {
1390								if r#valid_from_property.is_some() {
1391									return Err(<A::Error as de::Error>::duplicate_field(
1392										"validFrom",
1393									));
1394								}
1395								r#valid_from_property = Some({
1396									struct DeserializeWith(Vec<ValidFromProperty>);
1397									impl<'de> Deserialize<'de> for DeserializeWith {
1398										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1399										where
1400											D: Deserializer<'de>,
1401										{
1402											Ok(DeserializeWith(serde_with::As::<
1403												serde_with::OneOrMany<serde_with::Same>,
1404											>::deserialize(deserializer)?))
1405										}
1406									}
1407									match map.next_value::<DeserializeWith>() {
1408										Ok(deserialize_with) => deserialize_with.0,
1409										Err(err) => {
1410											return Err(err);
1411										}
1412									}
1413								});
1414							}
1415							Field::ValidThrough => {
1416								if r#valid_through_property.is_some() {
1417									return Err(<A::Error as de::Error>::duplicate_field(
1418										"validThrough",
1419									));
1420								}
1421								r#valid_through_property = Some({
1422									struct DeserializeWith(Vec<ValidThroughProperty>);
1423									impl<'de> Deserialize<'de> for DeserializeWith {
1424										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1425										where
1426											D: Deserializer<'de>,
1427										{
1428											Ok(DeserializeWith(serde_with::As::<
1429												serde_with::OneOrMany<serde_with::Same>,
1430											>::deserialize(deserializer)?))
1431										}
1432									}
1433									match map.next_value::<DeserializeWith>() {
1434										Ok(deserialize_with) => deserialize_with.0,
1435										Err(err) => {
1436											return Err(err);
1437										}
1438									}
1439								});
1440							}
1441							Field::ValueAddedTaxIncluded => {
1442								if r#value_added_tax_included_property.is_some() {
1443									return Err(<A::Error as de::Error>::duplicate_field(
1444										"valueAddedTaxIncluded",
1445									));
1446								}
1447								r#value_added_tax_included_property = Some({
1448									struct DeserializeWith(Vec<ValueAddedTaxIncludedProperty>);
1449									impl<'de> Deserialize<'de> for DeserializeWith {
1450										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1451										where
1452											D: Deserializer<'de>,
1453										{
1454											Ok(DeserializeWith(serde_with::As::<
1455												serde_with::OneOrMany<serde_with::Same>,
1456											>::deserialize(deserializer)?))
1457										}
1458									}
1459									match map.next_value::<DeserializeWith>() {
1460										Ok(deserialize_with) => deserialize_with.0,
1461										Err(err) => {
1462											return Err(err);
1463										}
1464									}
1465								});
1466							}
1467							Field::AdditionalType => {
1468								if r#additional_type_property.is_some() {
1469									return Err(<A::Error as de::Error>::duplicate_field(
1470										"additionalType",
1471									));
1472								}
1473								r#additional_type_property = Some({
1474									struct DeserializeWith(Vec<AdditionalTypeProperty>);
1475									impl<'de> Deserialize<'de> for DeserializeWith {
1476										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1477										where
1478											D: Deserializer<'de>,
1479										{
1480											Ok(DeserializeWith(serde_with::As::<
1481												serde_with::OneOrMany<serde_with::Same>,
1482											>::deserialize(deserializer)?))
1483										}
1484									}
1485									match map.next_value::<DeserializeWith>() {
1486										Ok(deserialize_with) => deserialize_with.0,
1487										Err(err) => {
1488											return Err(err);
1489										}
1490									}
1491								});
1492							}
1493							Field::AlternateName => {
1494								if r#alternate_name_property.is_some() {
1495									return Err(<A::Error as de::Error>::duplicate_field(
1496										"alternateName",
1497									));
1498								}
1499								r#alternate_name_property = Some({
1500									struct DeserializeWith(Vec<AlternateNameProperty>);
1501									impl<'de> Deserialize<'de> for DeserializeWith {
1502										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1503										where
1504											D: Deserializer<'de>,
1505										{
1506											Ok(DeserializeWith(serde_with::As::<
1507												serde_with::OneOrMany<serde_with::Same>,
1508											>::deserialize(deserializer)?))
1509										}
1510									}
1511									match map.next_value::<DeserializeWith>() {
1512										Ok(deserialize_with) => deserialize_with.0,
1513										Err(err) => {
1514											return Err(err);
1515										}
1516									}
1517								});
1518							}
1519							Field::Description => {
1520								if r#description_property.is_some() {
1521									return Err(<A::Error as de::Error>::duplicate_field(
1522										"description",
1523									));
1524								}
1525								r#description_property = Some({
1526									struct DeserializeWith(Vec<DescriptionProperty>);
1527									impl<'de> Deserialize<'de> for DeserializeWith {
1528										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1529										where
1530											D: Deserializer<'de>,
1531										{
1532											Ok(DeserializeWith(serde_with::As::<
1533												serde_with::OneOrMany<serde_with::Same>,
1534											>::deserialize(deserializer)?))
1535										}
1536									}
1537									match map.next_value::<DeserializeWith>() {
1538										Ok(deserialize_with) => deserialize_with.0,
1539										Err(err) => {
1540											return Err(err);
1541										}
1542									}
1543								});
1544							}
1545							Field::DisambiguatingDescription => {
1546								if r#disambiguating_description_property.is_some() {
1547									return Err(<A::Error as de::Error>::duplicate_field(
1548										"disambiguatingDescription",
1549									));
1550								}
1551								r#disambiguating_description_property = Some({
1552									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1553									impl<'de> Deserialize<'de> for DeserializeWith {
1554										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1555										where
1556											D: Deserializer<'de>,
1557										{
1558											Ok(DeserializeWith(serde_with::As::<
1559												serde_with::OneOrMany<serde_with::Same>,
1560											>::deserialize(deserializer)?))
1561										}
1562									}
1563									match map.next_value::<DeserializeWith>() {
1564										Ok(deserialize_with) => deserialize_with.0,
1565										Err(err) => {
1566											return Err(err);
1567										}
1568									}
1569								});
1570							}
1571							Field::Identifier => {
1572								if r#identifier_property.is_some() {
1573									return Err(<A::Error as de::Error>::duplicate_field(
1574										"identifier",
1575									));
1576								}
1577								r#identifier_property = Some({
1578									struct DeserializeWith(Vec<IdentifierProperty>);
1579									impl<'de> Deserialize<'de> for DeserializeWith {
1580										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1581										where
1582											D: Deserializer<'de>,
1583										{
1584											Ok(DeserializeWith(serde_with::As::<
1585												serde_with::OneOrMany<serde_with::Same>,
1586											>::deserialize(deserializer)?))
1587										}
1588									}
1589									match map.next_value::<DeserializeWith>() {
1590										Ok(deserialize_with) => deserialize_with.0,
1591										Err(err) => {
1592											return Err(err);
1593										}
1594									}
1595								});
1596							}
1597							Field::Image => {
1598								if r#image_property.is_some() {
1599									return Err(<A::Error as de::Error>::duplicate_field("image"));
1600								}
1601								r#image_property = Some({
1602									struct DeserializeWith(Vec<ImageProperty>);
1603									impl<'de> Deserialize<'de> for DeserializeWith {
1604										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1605										where
1606											D: Deserializer<'de>,
1607										{
1608											Ok(DeserializeWith(serde_with::As::<
1609												serde_with::OneOrMany<serde_with::Same>,
1610											>::deserialize(deserializer)?))
1611										}
1612									}
1613									match map.next_value::<DeserializeWith>() {
1614										Ok(deserialize_with) => deserialize_with.0,
1615										Err(err) => {
1616											return Err(err);
1617										}
1618									}
1619								});
1620							}
1621							Field::MainEntityOfPage => {
1622								if r#main_entity_of_page_property.is_some() {
1623									return Err(<A::Error as de::Error>::duplicate_field(
1624										"mainEntityOfPage",
1625									));
1626								}
1627								r#main_entity_of_page_property = Some({
1628									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1629									impl<'de> Deserialize<'de> for DeserializeWith {
1630										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1631										where
1632											D: Deserializer<'de>,
1633										{
1634											Ok(DeserializeWith(serde_with::As::<
1635												serde_with::OneOrMany<serde_with::Same>,
1636											>::deserialize(deserializer)?))
1637										}
1638									}
1639									match map.next_value::<DeserializeWith>() {
1640										Ok(deserialize_with) => deserialize_with.0,
1641										Err(err) => {
1642											return Err(err);
1643										}
1644									}
1645								});
1646							}
1647							Field::Name => {
1648								if r#name_property.is_some() {
1649									return Err(<A::Error as de::Error>::duplicate_field("name"));
1650								}
1651								r#name_property = Some({
1652									struct DeserializeWith(Vec<NameProperty>);
1653									impl<'de> Deserialize<'de> for DeserializeWith {
1654										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1655										where
1656											D: Deserializer<'de>,
1657										{
1658											Ok(DeserializeWith(serde_with::As::<
1659												serde_with::OneOrMany<serde_with::Same>,
1660											>::deserialize(deserializer)?))
1661										}
1662									}
1663									match map.next_value::<DeserializeWith>() {
1664										Ok(deserialize_with) => deserialize_with.0,
1665										Err(err) => {
1666											return Err(err);
1667										}
1668									}
1669								});
1670							}
1671							Field::PotentialAction => {
1672								if r#potential_action_property.is_some() {
1673									return Err(<A::Error as de::Error>::duplicate_field(
1674										"potentialAction",
1675									));
1676								}
1677								r#potential_action_property = Some({
1678									struct DeserializeWith(Vec<PotentialActionProperty>);
1679									impl<'de> Deserialize<'de> for DeserializeWith {
1680										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1681										where
1682											D: Deserializer<'de>,
1683										{
1684											Ok(DeserializeWith(serde_with::As::<
1685												serde_with::OneOrMany<serde_with::Same>,
1686											>::deserialize(deserializer)?))
1687										}
1688									}
1689									match map.next_value::<DeserializeWith>() {
1690										Ok(deserialize_with) => deserialize_with.0,
1691										Err(err) => {
1692											return Err(err);
1693										}
1694									}
1695								});
1696							}
1697							Field::SameAs => {
1698								if r#same_as_property.is_some() {
1699									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1700								}
1701								r#same_as_property = Some({
1702									struct DeserializeWith(Vec<SameAsProperty>);
1703									impl<'de> Deserialize<'de> for DeserializeWith {
1704										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1705										where
1706											D: Deserializer<'de>,
1707										{
1708											Ok(DeserializeWith(serde_with::As::<
1709												serde_with::OneOrMany<serde_with::Same>,
1710											>::deserialize(deserializer)?))
1711										}
1712									}
1713									match map.next_value::<DeserializeWith>() {
1714										Ok(deserialize_with) => deserialize_with.0,
1715										Err(err) => {
1716											return Err(err);
1717										}
1718									}
1719								});
1720							}
1721							Field::SubjectOf => {
1722								if r#subject_of_property.is_some() {
1723									return Err(<A::Error as de::Error>::duplicate_field(
1724										"subjectOf",
1725									));
1726								}
1727								r#subject_of_property = Some({
1728									struct DeserializeWith(Vec<SubjectOfProperty>);
1729									impl<'de> Deserialize<'de> for DeserializeWith {
1730										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1731										where
1732											D: Deserializer<'de>,
1733										{
1734											Ok(DeserializeWith(serde_with::As::<
1735												serde_with::OneOrMany<serde_with::Same>,
1736											>::deserialize(deserializer)?))
1737										}
1738									}
1739									match map.next_value::<DeserializeWith>() {
1740										Ok(deserialize_with) => deserialize_with.0,
1741										Err(err) => {
1742											return Err(err);
1743										}
1744									}
1745								});
1746							}
1747							Field::Url => {
1748								if r#url_property.is_some() {
1749									return Err(<A::Error as de::Error>::duplicate_field("url"));
1750								}
1751								r#url_property = Some({
1752									struct DeserializeWith(Vec<UrlProperty>);
1753									impl<'de> Deserialize<'de> for DeserializeWith {
1754										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1755										where
1756											D: Deserializer<'de>,
1757										{
1758											Ok(DeserializeWith(serde_with::As::<
1759												serde_with::OneOrMany<serde_with::Same>,
1760											>::deserialize(deserializer)?))
1761										}
1762									}
1763									match map.next_value::<DeserializeWith>() {
1764										Ok(deserialize_with) => deserialize_with.0,
1765										Err(err) => {
1766											return Err(err);
1767										}
1768									}
1769								});
1770							}
1771							Field::Ignore => {
1772								let _ = map.next_value::<de::IgnoredAny>()?;
1773							}
1774						}
1775					}
1776					Ok(UnitPriceSpecification {
1777						r#billing_duration: r#billing_duration_property.unwrap_or_default(),
1778						r#billing_increment: r#billing_increment_property.unwrap_or_default(),
1779						r#billing_start: r#billing_start_property.unwrap_or_default(),
1780						r#price_component_type: r#price_component_type_property.unwrap_or_default(),
1781						r#price_type: r#price_type_property.unwrap_or_default(),
1782						r#reference_quantity: r#reference_quantity_property.unwrap_or_default(),
1783						r#unit_code: r#unit_code_property.unwrap_or_default(),
1784						r#unit_text: r#unit_text_property.unwrap_or_default(),
1785						r#eligible_quantity: r#eligible_quantity_property.unwrap_or_default(),
1786						r#eligible_transaction_volume: r#eligible_transaction_volume_property
1787							.unwrap_or_default(),
1788						r#max_price: r#max_price_property.unwrap_or_default(),
1789						r#min_price: r#min_price_property.unwrap_or_default(),
1790						r#price: r#price_property.unwrap_or_default(),
1791						r#price_currency: r#price_currency_property.unwrap_or_default(),
1792						r#valid_from: r#valid_from_property.unwrap_or_default(),
1793						r#valid_through: r#valid_through_property.unwrap_or_default(),
1794						r#value_added_tax_included: r#value_added_tax_included_property
1795							.unwrap_or_default(),
1796						r#additional_type: r#additional_type_property.unwrap_or_default(),
1797						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1798						r#description: r#description_property.unwrap_or_default(),
1799						r#disambiguating_description: r#disambiguating_description_property
1800							.unwrap_or_default(),
1801						r#identifier: r#identifier_property.unwrap_or_default(),
1802						r#image: r#image_property.unwrap_or_default(),
1803						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1804						r#name: r#name_property.unwrap_or_default(),
1805						r#potential_action: r#potential_action_property.unwrap_or_default(),
1806						r#same_as: r#same_as_property.unwrap_or_default(),
1807						r#subject_of: r#subject_of_property.unwrap_or_default(),
1808						r#url: r#url_property.unwrap_or_default(),
1809					})
1810				}
1811			}
1812			const FIELDS: &[&str] = &[
1813				"billingDuration",
1814				"billingIncrement",
1815				"billingStart",
1816				"priceComponentType",
1817				"priceType",
1818				"referenceQuantity",
1819				"unitCode",
1820				"unitText",
1821				"eligibleQuantity",
1822				"eligibleTransactionVolume",
1823				"maxPrice",
1824				"minPrice",
1825				"price",
1826				"priceCurrency",
1827				"validFrom",
1828				"validThrough",
1829				"valueAddedTaxIncluded",
1830				"additionalType",
1831				"alternateName",
1832				"description",
1833				"disambiguatingDescription",
1834				"identifier",
1835				"image",
1836				"mainEntityOfPage",
1837				"name",
1838				"potentialAction",
1839				"sameAs",
1840				"subjectOf",
1841				"url",
1842			];
1843			deserializer.deserialize_struct("UnitPriceSpecification", FIELDS, ClassVisitor)
1844		}
1845	}
1846}