schema_org_types/schemas/classes/
compound_price_specification.rs

1use super::*;
2/// <https://schema.org/CompoundPriceSpecification>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct CompoundPriceSpecification {
6	/// <https://schema.org/priceComponent>
7	pub r#price_component: Vec<PriceComponentProperty>,
8	/// <https://schema.org/priceType>
9	pub r#price_type: Vec<PriceTypeProperty>,
10	/// <https://schema.org/eligibleQuantity>
11	pub r#eligible_quantity: Vec<EligibleQuantityProperty>,
12	/// <https://schema.org/eligibleTransactionVolume>
13	pub r#eligible_transaction_volume: Vec<EligibleTransactionVolumeProperty>,
14	/// <https://schema.org/maxPrice>
15	pub r#max_price: Vec<MaxPriceProperty>,
16	/// <https://schema.org/minPrice>
17	pub r#min_price: Vec<MinPriceProperty>,
18	/// <https://schema.org/price>
19	pub r#price: Vec<PriceProperty>,
20	/// <https://schema.org/priceCurrency>
21	pub r#price_currency: Vec<PriceCurrencyProperty>,
22	/// <https://schema.org/validFrom>
23	pub r#valid_from: Vec<ValidFromProperty>,
24	/// <https://schema.org/validThrough>
25	pub r#valid_through: Vec<ValidThroughProperty>,
26	/// <https://schema.org/valueAddedTaxIncluded>
27	pub r#value_added_tax_included: Vec<ValueAddedTaxIncludedProperty>,
28	/// <https://schema.org/additionalType>
29	pub r#additional_type: Vec<AdditionalTypeProperty>,
30	/// <https://schema.org/alternateName>
31	pub r#alternate_name: Vec<AlternateNameProperty>,
32	/// <https://schema.org/description>
33	pub r#description: Vec<DescriptionProperty>,
34	/// <https://schema.org/disambiguatingDescription>
35	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
36	/// <https://schema.org/identifier>
37	pub r#identifier: Vec<IdentifierProperty>,
38	/// <https://schema.org/image>
39	pub r#image: Vec<ImageProperty>,
40	/// <https://schema.org/mainEntityOfPage>
41	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
42	/// <https://schema.org/name>
43	pub r#name: Vec<NameProperty>,
44	/// <https://schema.org/potentialAction>
45	pub r#potential_action: Vec<PotentialActionProperty>,
46	/// <https://schema.org/sameAs>
47	pub r#same_as: Vec<SameAsProperty>,
48	/// <https://schema.org/subjectOf>
49	pub r#subject_of: Vec<SubjectOfProperty>,
50	/// <https://schema.org/url>
51	pub r#url: Vec<UrlProperty>,
52}
53/// This trait is for properties from <https://schema.org/CompoundPriceSpecification>.
54pub trait CompoundPriceSpecificationTrait {
55	/// Get <https://schema.org/priceComponent> from [`Self`] as borrowed slice.
56	fn get_price_component(&self) -> &[PriceComponentProperty];
57	/// Take <https://schema.org/priceComponent> from [`Self`] as owned vector.
58	fn take_price_component(&mut self) -> Vec<PriceComponentProperty>;
59	/// Get <https://schema.org/priceType> from [`Self`] as borrowed slice.
60	fn get_price_type(&self) -> &[PriceTypeProperty];
61	/// Take <https://schema.org/priceType> from [`Self`] as owned vector.
62	fn take_price_type(&mut self) -> Vec<PriceTypeProperty>;
63}
64impl CompoundPriceSpecificationTrait for CompoundPriceSpecification {
65	fn get_price_component(&self) -> &[PriceComponentProperty] {
66		self.r#price_component.as_slice()
67	}
68	fn take_price_component(&mut self) -> Vec<PriceComponentProperty> {
69		std::mem::take(&mut self.r#price_component)
70	}
71	fn get_price_type(&self) -> &[PriceTypeProperty] {
72		self.r#price_type.as_slice()
73	}
74	fn take_price_type(&mut self) -> Vec<PriceTypeProperty> {
75		std::mem::take(&mut self.r#price_type)
76	}
77}
78impl PriceSpecificationTrait for CompoundPriceSpecification {
79	fn get_eligible_quantity(&self) -> &[EligibleQuantityProperty] {
80		self.r#eligible_quantity.as_slice()
81	}
82	fn take_eligible_quantity(&mut self) -> Vec<EligibleQuantityProperty> {
83		std::mem::take(&mut self.r#eligible_quantity)
84	}
85	fn get_eligible_transaction_volume(&self) -> &[EligibleTransactionVolumeProperty] {
86		self.r#eligible_transaction_volume.as_slice()
87	}
88	fn take_eligible_transaction_volume(&mut self) -> Vec<EligibleTransactionVolumeProperty> {
89		std::mem::take(&mut self.r#eligible_transaction_volume)
90	}
91	fn get_max_price(&self) -> &[MaxPriceProperty] {
92		self.r#max_price.as_slice()
93	}
94	fn take_max_price(&mut self) -> Vec<MaxPriceProperty> {
95		std::mem::take(&mut self.r#max_price)
96	}
97	fn get_min_price(&self) -> &[MinPriceProperty] {
98		self.r#min_price.as_slice()
99	}
100	fn take_min_price(&mut self) -> Vec<MinPriceProperty> {
101		std::mem::take(&mut self.r#min_price)
102	}
103	fn get_price(&self) -> &[PriceProperty] {
104		self.r#price.as_slice()
105	}
106	fn take_price(&mut self) -> Vec<PriceProperty> {
107		std::mem::take(&mut self.r#price)
108	}
109	fn get_price_currency(&self) -> &[PriceCurrencyProperty] {
110		self.r#price_currency.as_slice()
111	}
112	fn take_price_currency(&mut self) -> Vec<PriceCurrencyProperty> {
113		std::mem::take(&mut self.r#price_currency)
114	}
115	fn get_valid_from(&self) -> &[ValidFromProperty] {
116		self.r#valid_from.as_slice()
117	}
118	fn take_valid_from(&mut self) -> Vec<ValidFromProperty> {
119		std::mem::take(&mut self.r#valid_from)
120	}
121	fn get_valid_through(&self) -> &[ValidThroughProperty] {
122		self.r#valid_through.as_slice()
123	}
124	fn take_valid_through(&mut self) -> Vec<ValidThroughProperty> {
125		std::mem::take(&mut self.r#valid_through)
126	}
127	fn get_value_added_tax_included(&self) -> &[ValueAddedTaxIncludedProperty] {
128		self.r#value_added_tax_included.as_slice()
129	}
130	fn take_value_added_tax_included(&mut self) -> Vec<ValueAddedTaxIncludedProperty> {
131		std::mem::take(&mut self.r#value_added_tax_included)
132	}
133}
134impl StructuredValueTrait for CompoundPriceSpecification {}
135impl ThingTrait for CompoundPriceSpecification {
136	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
137		self.r#additional_type.as_slice()
138	}
139	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
140		std::mem::take(&mut self.r#additional_type)
141	}
142	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
143		self.r#alternate_name.as_slice()
144	}
145	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
146		std::mem::take(&mut self.r#alternate_name)
147	}
148	fn get_description(&self) -> &[DescriptionProperty] {
149		self.r#description.as_slice()
150	}
151	fn take_description(&mut self) -> Vec<DescriptionProperty> {
152		std::mem::take(&mut self.r#description)
153	}
154	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
155		self.r#disambiguating_description.as_slice()
156	}
157	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
158		std::mem::take(&mut self.r#disambiguating_description)
159	}
160	fn get_identifier(&self) -> &[IdentifierProperty] {
161		self.r#identifier.as_slice()
162	}
163	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
164		std::mem::take(&mut self.r#identifier)
165	}
166	fn get_image(&self) -> &[ImageProperty] {
167		self.r#image.as_slice()
168	}
169	fn take_image(&mut self) -> Vec<ImageProperty> {
170		std::mem::take(&mut self.r#image)
171	}
172	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
173		self.r#main_entity_of_page.as_slice()
174	}
175	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
176		std::mem::take(&mut self.r#main_entity_of_page)
177	}
178	fn get_name(&self) -> &[NameProperty] {
179		self.r#name.as_slice()
180	}
181	fn take_name(&mut self) -> Vec<NameProperty> {
182		std::mem::take(&mut self.r#name)
183	}
184	fn get_potential_action(&self) -> &[PotentialActionProperty] {
185		self.r#potential_action.as_slice()
186	}
187	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
188		std::mem::take(&mut self.r#potential_action)
189	}
190	fn get_same_as(&self) -> &[SameAsProperty] {
191		self.r#same_as.as_slice()
192	}
193	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
194		std::mem::take(&mut self.r#same_as)
195	}
196	fn get_subject_of(&self) -> &[SubjectOfProperty] {
197		self.r#subject_of.as_slice()
198	}
199	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
200		std::mem::take(&mut self.r#subject_of)
201	}
202	fn get_url(&self) -> &[UrlProperty] {
203		self.r#url.as_slice()
204	}
205	fn take_url(&mut self) -> Vec<UrlProperty> {
206		std::mem::take(&mut self.r#url)
207	}
208}
209#[cfg(feature = "serde")]
210mod serde {
211	use std::{fmt, fmt::Formatter};
212
213	use ::serde::{
214		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
215	};
216
217	use super::*;
218	impl Serialize for CompoundPriceSpecification {
219		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
220		where
221			S: Serializer,
222		{
223			let len: usize = [
224				!Vec::is_empty(&self.r#price_component) as usize,
225				!Vec::is_empty(&self.r#price_type) as usize,
226				!Vec::is_empty(&self.r#eligible_quantity) as usize,
227				!Vec::is_empty(&self.r#eligible_transaction_volume) as usize,
228				!Vec::is_empty(&self.r#max_price) as usize,
229				!Vec::is_empty(&self.r#min_price) as usize,
230				!Vec::is_empty(&self.r#price) as usize,
231				!Vec::is_empty(&self.r#price_currency) as usize,
232				!Vec::is_empty(&self.r#valid_from) as usize,
233				!Vec::is_empty(&self.r#valid_through) as usize,
234				!Vec::is_empty(&self.r#value_added_tax_included) as usize,
235				!Vec::is_empty(&self.r#additional_type) as usize,
236				!Vec::is_empty(&self.r#alternate_name) as usize,
237				!Vec::is_empty(&self.r#description) as usize,
238				!Vec::is_empty(&self.r#disambiguating_description) as usize,
239				!Vec::is_empty(&self.r#identifier) as usize,
240				!Vec::is_empty(&self.r#image) as usize,
241				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
242				!Vec::is_empty(&self.r#name) as usize,
243				!Vec::is_empty(&self.r#potential_action) as usize,
244				!Vec::is_empty(&self.r#same_as) as usize,
245				!Vec::is_empty(&self.r#subject_of) as usize,
246				!Vec::is_empty(&self.r#url) as usize,
247			]
248			.iter()
249			.sum();
250			let mut serialize_struct =
251				Serializer::serialize_struct(serializer, "CompoundPriceSpecification", len)?;
252			if !Vec::is_empty(&self.r#price_component) {
253				serialize_struct.serialize_field("priceComponent", {
254					struct SerializeWith<'a>(&'a Vec<PriceComponentProperty>);
255					impl<'a> Serialize for SerializeWith<'a> {
256						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
257						where
258							S: Serializer,
259						{
260							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
261								self.0, serializer,
262							)
263						}
264					}
265					&SerializeWith(&self.r#price_component)
266				})?;
267			} else {
268				serialize_struct.skip_field("priceComponent")?;
269			}
270			if !Vec::is_empty(&self.r#price_type) {
271				serialize_struct.serialize_field("priceType", {
272					struct SerializeWith<'a>(&'a Vec<PriceTypeProperty>);
273					impl<'a> Serialize for SerializeWith<'a> {
274						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
275						where
276							S: Serializer,
277						{
278							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
279								self.0, serializer,
280							)
281						}
282					}
283					&SerializeWith(&self.r#price_type)
284				})?;
285			} else {
286				serialize_struct.skip_field("priceType")?;
287			}
288			if !Vec::is_empty(&self.r#eligible_quantity) {
289				serialize_struct.serialize_field("eligibleQuantity", {
290					struct SerializeWith<'a>(&'a Vec<EligibleQuantityProperty>);
291					impl<'a> Serialize for SerializeWith<'a> {
292						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
293						where
294							S: Serializer,
295						{
296							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
297								self.0, serializer,
298							)
299						}
300					}
301					&SerializeWith(&self.r#eligible_quantity)
302				})?;
303			} else {
304				serialize_struct.skip_field("eligibleQuantity")?;
305			}
306			if !Vec::is_empty(&self.r#eligible_transaction_volume) {
307				serialize_struct.serialize_field("eligibleTransactionVolume", {
308					struct SerializeWith<'a>(&'a Vec<EligibleTransactionVolumeProperty>);
309					impl<'a> Serialize for SerializeWith<'a> {
310						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
311						where
312							S: Serializer,
313						{
314							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
315								self.0, serializer,
316							)
317						}
318					}
319					&SerializeWith(&self.r#eligible_transaction_volume)
320				})?;
321			} else {
322				serialize_struct.skip_field("eligibleTransactionVolume")?;
323			}
324			if !Vec::is_empty(&self.r#max_price) {
325				serialize_struct.serialize_field("maxPrice", {
326					struct SerializeWith<'a>(&'a Vec<MaxPriceProperty>);
327					impl<'a> Serialize for SerializeWith<'a> {
328						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
329						where
330							S: Serializer,
331						{
332							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
333								self.0, serializer,
334							)
335						}
336					}
337					&SerializeWith(&self.r#max_price)
338				})?;
339			} else {
340				serialize_struct.skip_field("maxPrice")?;
341			}
342			if !Vec::is_empty(&self.r#min_price) {
343				serialize_struct.serialize_field("minPrice", {
344					struct SerializeWith<'a>(&'a Vec<MinPriceProperty>);
345					impl<'a> Serialize for SerializeWith<'a> {
346						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
347						where
348							S: Serializer,
349						{
350							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
351								self.0, serializer,
352							)
353						}
354					}
355					&SerializeWith(&self.r#min_price)
356				})?;
357			} else {
358				serialize_struct.skip_field("minPrice")?;
359			}
360			if !Vec::is_empty(&self.r#price) {
361				serialize_struct.serialize_field("price", {
362					struct SerializeWith<'a>(&'a Vec<PriceProperty>);
363					impl<'a> Serialize for SerializeWith<'a> {
364						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
365						where
366							S: Serializer,
367						{
368							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
369								self.0, serializer,
370							)
371						}
372					}
373					&SerializeWith(&self.r#price)
374				})?;
375			} else {
376				serialize_struct.skip_field("price")?;
377			}
378			if !Vec::is_empty(&self.r#price_currency) {
379				serialize_struct.serialize_field("priceCurrency", {
380					struct SerializeWith<'a>(&'a Vec<PriceCurrencyProperty>);
381					impl<'a> Serialize for SerializeWith<'a> {
382						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
383						where
384							S: Serializer,
385						{
386							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
387								self.0, serializer,
388							)
389						}
390					}
391					&SerializeWith(&self.r#price_currency)
392				})?;
393			} else {
394				serialize_struct.skip_field("priceCurrency")?;
395			}
396			if !Vec::is_empty(&self.r#valid_from) {
397				serialize_struct.serialize_field("validFrom", {
398					struct SerializeWith<'a>(&'a Vec<ValidFromProperty>);
399					impl<'a> Serialize for SerializeWith<'a> {
400						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
401						where
402							S: Serializer,
403						{
404							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
405								self.0, serializer,
406							)
407						}
408					}
409					&SerializeWith(&self.r#valid_from)
410				})?;
411			} else {
412				serialize_struct.skip_field("validFrom")?;
413			}
414			if !Vec::is_empty(&self.r#valid_through) {
415				serialize_struct.serialize_field("validThrough", {
416					struct SerializeWith<'a>(&'a Vec<ValidThroughProperty>);
417					impl<'a> Serialize for SerializeWith<'a> {
418						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
419						where
420							S: Serializer,
421						{
422							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
423								self.0, serializer,
424							)
425						}
426					}
427					&SerializeWith(&self.r#valid_through)
428				})?;
429			} else {
430				serialize_struct.skip_field("validThrough")?;
431			}
432			if !Vec::is_empty(&self.r#value_added_tax_included) {
433				serialize_struct.serialize_field("valueAddedTaxIncluded", {
434					struct SerializeWith<'a>(&'a Vec<ValueAddedTaxIncludedProperty>);
435					impl<'a> Serialize for SerializeWith<'a> {
436						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
437						where
438							S: Serializer,
439						{
440							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
441								self.0, serializer,
442							)
443						}
444					}
445					&SerializeWith(&self.r#value_added_tax_included)
446				})?;
447			} else {
448				serialize_struct.skip_field("valueAddedTaxIncluded")?;
449			}
450			if !Vec::is_empty(&self.r#additional_type) {
451				serialize_struct.serialize_field("additionalType", {
452					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
453					impl<'a> Serialize for SerializeWith<'a> {
454						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
455						where
456							S: Serializer,
457						{
458							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
459								self.0, serializer,
460							)
461						}
462					}
463					&SerializeWith(&self.r#additional_type)
464				})?;
465			} else {
466				serialize_struct.skip_field("additionalType")?;
467			}
468			if !Vec::is_empty(&self.r#alternate_name) {
469				serialize_struct.serialize_field("alternateName", {
470					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
471					impl<'a> Serialize for SerializeWith<'a> {
472						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
473						where
474							S: Serializer,
475						{
476							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
477								self.0, serializer,
478							)
479						}
480					}
481					&SerializeWith(&self.r#alternate_name)
482				})?;
483			} else {
484				serialize_struct.skip_field("alternateName")?;
485			}
486			if !Vec::is_empty(&self.r#description) {
487				serialize_struct.serialize_field("description", {
488					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
489					impl<'a> Serialize for SerializeWith<'a> {
490						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
491						where
492							S: Serializer,
493						{
494							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
495								self.0, serializer,
496							)
497						}
498					}
499					&SerializeWith(&self.r#description)
500				})?;
501			} else {
502				serialize_struct.skip_field("description")?;
503			}
504			if !Vec::is_empty(&self.r#disambiguating_description) {
505				serialize_struct.serialize_field("disambiguatingDescription", {
506					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
507					impl<'a> Serialize for SerializeWith<'a> {
508						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
509						where
510							S: Serializer,
511						{
512							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
513								self.0, serializer,
514							)
515						}
516					}
517					&SerializeWith(&self.r#disambiguating_description)
518				})?;
519			} else {
520				serialize_struct.skip_field("disambiguatingDescription")?;
521			}
522			if !Vec::is_empty(&self.r#identifier) {
523				serialize_struct.serialize_field("identifier", {
524					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
525					impl<'a> Serialize for SerializeWith<'a> {
526						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
527						where
528							S: Serializer,
529						{
530							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
531								self.0, serializer,
532							)
533						}
534					}
535					&SerializeWith(&self.r#identifier)
536				})?;
537			} else {
538				serialize_struct.skip_field("identifier")?;
539			}
540			if !Vec::is_empty(&self.r#image) {
541				serialize_struct.serialize_field("image", {
542					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
543					impl<'a> Serialize for SerializeWith<'a> {
544						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
545						where
546							S: Serializer,
547						{
548							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
549								self.0, serializer,
550							)
551						}
552					}
553					&SerializeWith(&self.r#image)
554				})?;
555			} else {
556				serialize_struct.skip_field("image")?;
557			}
558			if !Vec::is_empty(&self.r#main_entity_of_page) {
559				serialize_struct.serialize_field("mainEntityOfPage", {
560					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
561					impl<'a> Serialize for SerializeWith<'a> {
562						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
563						where
564							S: Serializer,
565						{
566							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
567								self.0, serializer,
568							)
569						}
570					}
571					&SerializeWith(&self.r#main_entity_of_page)
572				})?;
573			} else {
574				serialize_struct.skip_field("mainEntityOfPage")?;
575			}
576			if !Vec::is_empty(&self.r#name) {
577				serialize_struct.serialize_field("name", {
578					struct SerializeWith<'a>(&'a Vec<NameProperty>);
579					impl<'a> Serialize for SerializeWith<'a> {
580						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
581						where
582							S: Serializer,
583						{
584							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
585								self.0, serializer,
586							)
587						}
588					}
589					&SerializeWith(&self.r#name)
590				})?;
591			} else {
592				serialize_struct.skip_field("name")?;
593			}
594			if !Vec::is_empty(&self.r#potential_action) {
595				serialize_struct.serialize_field("potentialAction", {
596					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
597					impl<'a> Serialize for SerializeWith<'a> {
598						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
599						where
600							S: Serializer,
601						{
602							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
603								self.0, serializer,
604							)
605						}
606					}
607					&SerializeWith(&self.r#potential_action)
608				})?;
609			} else {
610				serialize_struct.skip_field("potentialAction")?;
611			}
612			if !Vec::is_empty(&self.r#same_as) {
613				serialize_struct.serialize_field("sameAs", {
614					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
615					impl<'a> Serialize for SerializeWith<'a> {
616						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
617						where
618							S: Serializer,
619						{
620							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
621								self.0, serializer,
622							)
623						}
624					}
625					&SerializeWith(&self.r#same_as)
626				})?;
627			} else {
628				serialize_struct.skip_field("sameAs")?;
629			}
630			if !Vec::is_empty(&self.r#subject_of) {
631				serialize_struct.serialize_field("subjectOf", {
632					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
633					impl<'a> Serialize for SerializeWith<'a> {
634						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
635						where
636							S: Serializer,
637						{
638							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
639								self.0, serializer,
640							)
641						}
642					}
643					&SerializeWith(&self.r#subject_of)
644				})?;
645			} else {
646				serialize_struct.skip_field("subjectOf")?;
647			}
648			if !Vec::is_empty(&self.r#url) {
649				serialize_struct.serialize_field("url", {
650					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
651					impl<'a> Serialize for SerializeWith<'a> {
652						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
653						where
654							S: Serializer,
655						{
656							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
657								self.0, serializer,
658							)
659						}
660					}
661					&SerializeWith(&self.r#url)
662				})?;
663			} else {
664				serialize_struct.skip_field("url")?;
665			}
666			serialize_struct.end()
667		}
668	}
669	impl<'de> Deserialize<'de> for CompoundPriceSpecification {
670		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
671		where
672			D: Deserializer<'de>,
673		{
674			enum Field {
675				PriceComponent,
676				PriceType,
677				EligibleQuantity,
678				EligibleTransactionVolume,
679				MaxPrice,
680				MinPrice,
681				Price,
682				PriceCurrency,
683				ValidFrom,
684				ValidThrough,
685				ValueAddedTaxIncluded,
686				AdditionalType,
687				AlternateName,
688				Description,
689				DisambiguatingDescription,
690				Identifier,
691				Image,
692				MainEntityOfPage,
693				Name,
694				PotentialAction,
695				SameAs,
696				SubjectOf,
697				Url,
698				Ignore,
699			}
700			struct FieldVisitor;
701			impl<'de> Visitor<'de> for FieldVisitor {
702				type Value = Field;
703				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
704					formatter.write_str("field identifier")
705				}
706				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
707				where
708					E: de::Error,
709				{
710					match value {
711						"priceComponent" => Ok(Field::PriceComponent),
712						"priceType" => Ok(Field::PriceType),
713						"eligibleQuantity" => Ok(Field::EligibleQuantity),
714						"eligibleTransactionVolume" => Ok(Field::EligibleTransactionVolume),
715						"maxPrice" => Ok(Field::MaxPrice),
716						"minPrice" => Ok(Field::MinPrice),
717						"price" => Ok(Field::Price),
718						"priceCurrency" => Ok(Field::PriceCurrency),
719						"validFrom" => Ok(Field::ValidFrom),
720						"validThrough" => Ok(Field::ValidThrough),
721						"valueAddedTaxIncluded" => Ok(Field::ValueAddedTaxIncluded),
722						"additionalType" => Ok(Field::AdditionalType),
723						"alternateName" => Ok(Field::AlternateName),
724						"description" => Ok(Field::Description),
725						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
726						"identifier" => Ok(Field::Identifier),
727						"image" => Ok(Field::Image),
728						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
729						"name" => Ok(Field::Name),
730						"potentialAction" => Ok(Field::PotentialAction),
731						"sameAs" => Ok(Field::SameAs),
732						"subjectOf" => Ok(Field::SubjectOf),
733						"url" => Ok(Field::Url),
734						"id" | "type" => Ok(Field::Ignore),
735						_ => Err(de::Error::unknown_field(value, FIELDS)),
736					}
737				}
738				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
739				where
740					E: de::Error,
741				{
742					match value {
743						b"priceComponent" => Ok(Field::PriceComponent),
744						b"priceType" => Ok(Field::PriceType),
745						b"eligibleQuantity" => Ok(Field::EligibleQuantity),
746						b"eligibleTransactionVolume" => Ok(Field::EligibleTransactionVolume),
747						b"maxPrice" => Ok(Field::MaxPrice),
748						b"minPrice" => Ok(Field::MinPrice),
749						b"price" => Ok(Field::Price),
750						b"priceCurrency" => Ok(Field::PriceCurrency),
751						b"validFrom" => Ok(Field::ValidFrom),
752						b"validThrough" => Ok(Field::ValidThrough),
753						b"valueAddedTaxIncluded" => Ok(Field::ValueAddedTaxIncluded),
754						b"additionalType" => Ok(Field::AdditionalType),
755						b"alternateName" => Ok(Field::AlternateName),
756						b"description" => Ok(Field::Description),
757						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
758						b"identifier" => Ok(Field::Identifier),
759						b"image" => Ok(Field::Image),
760						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
761						b"name" => Ok(Field::Name),
762						b"potentialAction" => Ok(Field::PotentialAction),
763						b"sameAs" => Ok(Field::SameAs),
764						b"subjectOf" => Ok(Field::SubjectOf),
765						b"url" => Ok(Field::Url),
766						b"id" | b"type" => Ok(Field::Ignore),
767						_ => {
768							let value = &String::from_utf8_lossy(value);
769							Err(de::Error::unknown_field(value, FIELDS))
770						}
771					}
772				}
773			}
774			impl<'de> Deserialize<'de> for Field {
775				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
776				where
777					D: Deserializer<'de>,
778				{
779					deserializer.deserialize_identifier(FieldVisitor)
780				}
781			}
782			struct ClassVisitor;
783			impl<'de> Visitor<'de> for ClassVisitor {
784				type Value = CompoundPriceSpecification;
785				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
786					formatter.write_str("schema.org schema CompoundPriceSpecification")
787				}
788				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
789				where
790					A: de::MapAccess<'de>,
791				{
792					let mut r#price_component_property = None;
793					let mut r#price_type_property = None;
794					let mut r#eligible_quantity_property = None;
795					let mut r#eligible_transaction_volume_property = None;
796					let mut r#max_price_property = None;
797					let mut r#min_price_property = None;
798					let mut r#price_property = None;
799					let mut r#price_currency_property = None;
800					let mut r#valid_from_property = None;
801					let mut r#valid_through_property = None;
802					let mut r#value_added_tax_included_property = None;
803					let mut r#additional_type_property = None;
804					let mut r#alternate_name_property = None;
805					let mut r#description_property = None;
806					let mut r#disambiguating_description_property = None;
807					let mut r#identifier_property = None;
808					let mut r#image_property = None;
809					let mut r#main_entity_of_page_property = None;
810					let mut r#name_property = None;
811					let mut r#potential_action_property = None;
812					let mut r#same_as_property = None;
813					let mut r#subject_of_property = None;
814					let mut r#url_property = None;
815					while let Some(key) = map.next_key::<Field>()? {
816						match key {
817							Field::PriceComponent => {
818								if r#price_component_property.is_some() {
819									return Err(<A::Error as de::Error>::duplicate_field(
820										"priceComponent",
821									));
822								}
823								r#price_component_property = Some({
824									struct DeserializeWith(Vec<PriceComponentProperty>);
825									impl<'de> Deserialize<'de> for DeserializeWith {
826										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
827										where
828											D: Deserializer<'de>,
829										{
830											Ok(DeserializeWith(serde_with::As::<
831												serde_with::OneOrMany<serde_with::Same>,
832											>::deserialize(deserializer)?))
833										}
834									}
835									match map.next_value::<DeserializeWith>() {
836										Ok(deserialize_with) => deserialize_with.0,
837										Err(err) => {
838											return Err(err);
839										}
840									}
841								});
842							}
843							Field::PriceType => {
844								if r#price_type_property.is_some() {
845									return Err(<A::Error as de::Error>::duplicate_field(
846										"priceType",
847									));
848								}
849								r#price_type_property = Some({
850									struct DeserializeWith(Vec<PriceTypeProperty>);
851									impl<'de> Deserialize<'de> for DeserializeWith {
852										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
853										where
854											D: Deserializer<'de>,
855										{
856											Ok(DeserializeWith(serde_with::As::<
857												serde_with::OneOrMany<serde_with::Same>,
858											>::deserialize(deserializer)?))
859										}
860									}
861									match map.next_value::<DeserializeWith>() {
862										Ok(deserialize_with) => deserialize_with.0,
863										Err(err) => {
864											return Err(err);
865										}
866									}
867								});
868							}
869							Field::EligibleQuantity => {
870								if r#eligible_quantity_property.is_some() {
871									return Err(<A::Error as de::Error>::duplicate_field(
872										"eligibleQuantity",
873									));
874								}
875								r#eligible_quantity_property = Some({
876									struct DeserializeWith(Vec<EligibleQuantityProperty>);
877									impl<'de> Deserialize<'de> for DeserializeWith {
878										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
879										where
880											D: Deserializer<'de>,
881										{
882											Ok(DeserializeWith(serde_with::As::<
883												serde_with::OneOrMany<serde_with::Same>,
884											>::deserialize(deserializer)?))
885										}
886									}
887									match map.next_value::<DeserializeWith>() {
888										Ok(deserialize_with) => deserialize_with.0,
889										Err(err) => {
890											return Err(err);
891										}
892									}
893								});
894							}
895							Field::EligibleTransactionVolume => {
896								if r#eligible_transaction_volume_property.is_some() {
897									return Err(<A::Error as de::Error>::duplicate_field(
898										"eligibleTransactionVolume",
899									));
900								}
901								r#eligible_transaction_volume_property = Some({
902									struct DeserializeWith(Vec<EligibleTransactionVolumeProperty>);
903									impl<'de> Deserialize<'de> for DeserializeWith {
904										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
905										where
906											D: Deserializer<'de>,
907										{
908											Ok(DeserializeWith(serde_with::As::<
909												serde_with::OneOrMany<serde_with::Same>,
910											>::deserialize(deserializer)?))
911										}
912									}
913									match map.next_value::<DeserializeWith>() {
914										Ok(deserialize_with) => deserialize_with.0,
915										Err(err) => {
916											return Err(err);
917										}
918									}
919								});
920							}
921							Field::MaxPrice => {
922								if r#max_price_property.is_some() {
923									return Err(<A::Error as de::Error>::duplicate_field(
924										"maxPrice",
925									));
926								}
927								r#max_price_property = Some({
928									struct DeserializeWith(Vec<MaxPriceProperty>);
929									impl<'de> Deserialize<'de> for DeserializeWith {
930										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
931										where
932											D: Deserializer<'de>,
933										{
934											Ok(DeserializeWith(serde_with::As::<
935												serde_with::OneOrMany<serde_with::Same>,
936											>::deserialize(deserializer)?))
937										}
938									}
939									match map.next_value::<DeserializeWith>() {
940										Ok(deserialize_with) => deserialize_with.0,
941										Err(err) => {
942											return Err(err);
943										}
944									}
945								});
946							}
947							Field::MinPrice => {
948								if r#min_price_property.is_some() {
949									return Err(<A::Error as de::Error>::duplicate_field(
950										"minPrice",
951									));
952								}
953								r#min_price_property = Some({
954									struct DeserializeWith(Vec<MinPriceProperty>);
955									impl<'de> Deserialize<'de> for DeserializeWith {
956										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
957										where
958											D: Deserializer<'de>,
959										{
960											Ok(DeserializeWith(serde_with::As::<
961												serde_with::OneOrMany<serde_with::Same>,
962											>::deserialize(deserializer)?))
963										}
964									}
965									match map.next_value::<DeserializeWith>() {
966										Ok(deserialize_with) => deserialize_with.0,
967										Err(err) => {
968											return Err(err);
969										}
970									}
971								});
972							}
973							Field::Price => {
974								if r#price_property.is_some() {
975									return Err(<A::Error as de::Error>::duplicate_field("price"));
976								}
977								r#price_property = Some({
978									struct DeserializeWith(Vec<PriceProperty>);
979									impl<'de> Deserialize<'de> for DeserializeWith {
980										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
981										where
982											D: Deserializer<'de>,
983										{
984											Ok(DeserializeWith(serde_with::As::<
985												serde_with::OneOrMany<serde_with::Same>,
986											>::deserialize(deserializer)?))
987										}
988									}
989									match map.next_value::<DeserializeWith>() {
990										Ok(deserialize_with) => deserialize_with.0,
991										Err(err) => {
992											return Err(err);
993										}
994									}
995								});
996							}
997							Field::PriceCurrency => {
998								if r#price_currency_property.is_some() {
999									return Err(<A::Error as de::Error>::duplicate_field(
1000										"priceCurrency",
1001									));
1002								}
1003								r#price_currency_property = Some({
1004									struct DeserializeWith(Vec<PriceCurrencyProperty>);
1005									impl<'de> Deserialize<'de> for DeserializeWith {
1006										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1007										where
1008											D: Deserializer<'de>,
1009										{
1010											Ok(DeserializeWith(serde_with::As::<
1011												serde_with::OneOrMany<serde_with::Same>,
1012											>::deserialize(deserializer)?))
1013										}
1014									}
1015									match map.next_value::<DeserializeWith>() {
1016										Ok(deserialize_with) => deserialize_with.0,
1017										Err(err) => {
1018											return Err(err);
1019										}
1020									}
1021								});
1022							}
1023							Field::ValidFrom => {
1024								if r#valid_from_property.is_some() {
1025									return Err(<A::Error as de::Error>::duplicate_field(
1026										"validFrom",
1027									));
1028								}
1029								r#valid_from_property = Some({
1030									struct DeserializeWith(Vec<ValidFromProperty>);
1031									impl<'de> Deserialize<'de> for DeserializeWith {
1032										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1033										where
1034											D: Deserializer<'de>,
1035										{
1036											Ok(DeserializeWith(serde_with::As::<
1037												serde_with::OneOrMany<serde_with::Same>,
1038											>::deserialize(deserializer)?))
1039										}
1040									}
1041									match map.next_value::<DeserializeWith>() {
1042										Ok(deserialize_with) => deserialize_with.0,
1043										Err(err) => {
1044											return Err(err);
1045										}
1046									}
1047								});
1048							}
1049							Field::ValidThrough => {
1050								if r#valid_through_property.is_some() {
1051									return Err(<A::Error as de::Error>::duplicate_field(
1052										"validThrough",
1053									));
1054								}
1055								r#valid_through_property = Some({
1056									struct DeserializeWith(Vec<ValidThroughProperty>);
1057									impl<'de> Deserialize<'de> for DeserializeWith {
1058										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1059										where
1060											D: Deserializer<'de>,
1061										{
1062											Ok(DeserializeWith(serde_with::As::<
1063												serde_with::OneOrMany<serde_with::Same>,
1064											>::deserialize(deserializer)?))
1065										}
1066									}
1067									match map.next_value::<DeserializeWith>() {
1068										Ok(deserialize_with) => deserialize_with.0,
1069										Err(err) => {
1070											return Err(err);
1071										}
1072									}
1073								});
1074							}
1075							Field::ValueAddedTaxIncluded => {
1076								if r#value_added_tax_included_property.is_some() {
1077									return Err(<A::Error as de::Error>::duplicate_field(
1078										"valueAddedTaxIncluded",
1079									));
1080								}
1081								r#value_added_tax_included_property = Some({
1082									struct DeserializeWith(Vec<ValueAddedTaxIncludedProperty>);
1083									impl<'de> Deserialize<'de> for DeserializeWith {
1084										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1085										where
1086											D: Deserializer<'de>,
1087										{
1088											Ok(DeserializeWith(serde_with::As::<
1089												serde_with::OneOrMany<serde_with::Same>,
1090											>::deserialize(deserializer)?))
1091										}
1092									}
1093									match map.next_value::<DeserializeWith>() {
1094										Ok(deserialize_with) => deserialize_with.0,
1095										Err(err) => {
1096											return Err(err);
1097										}
1098									}
1099								});
1100							}
1101							Field::AdditionalType => {
1102								if r#additional_type_property.is_some() {
1103									return Err(<A::Error as de::Error>::duplicate_field(
1104										"additionalType",
1105									));
1106								}
1107								r#additional_type_property = Some({
1108									struct DeserializeWith(Vec<AdditionalTypeProperty>);
1109									impl<'de> Deserialize<'de> for DeserializeWith {
1110										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1111										where
1112											D: Deserializer<'de>,
1113										{
1114											Ok(DeserializeWith(serde_with::As::<
1115												serde_with::OneOrMany<serde_with::Same>,
1116											>::deserialize(deserializer)?))
1117										}
1118									}
1119									match map.next_value::<DeserializeWith>() {
1120										Ok(deserialize_with) => deserialize_with.0,
1121										Err(err) => {
1122											return Err(err);
1123										}
1124									}
1125								});
1126							}
1127							Field::AlternateName => {
1128								if r#alternate_name_property.is_some() {
1129									return Err(<A::Error as de::Error>::duplicate_field(
1130										"alternateName",
1131									));
1132								}
1133								r#alternate_name_property = Some({
1134									struct DeserializeWith(Vec<AlternateNameProperty>);
1135									impl<'de> Deserialize<'de> for DeserializeWith {
1136										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1137										where
1138											D: Deserializer<'de>,
1139										{
1140											Ok(DeserializeWith(serde_with::As::<
1141												serde_with::OneOrMany<serde_with::Same>,
1142											>::deserialize(deserializer)?))
1143										}
1144									}
1145									match map.next_value::<DeserializeWith>() {
1146										Ok(deserialize_with) => deserialize_with.0,
1147										Err(err) => {
1148											return Err(err);
1149										}
1150									}
1151								});
1152							}
1153							Field::Description => {
1154								if r#description_property.is_some() {
1155									return Err(<A::Error as de::Error>::duplicate_field(
1156										"description",
1157									));
1158								}
1159								r#description_property = Some({
1160									struct DeserializeWith(Vec<DescriptionProperty>);
1161									impl<'de> Deserialize<'de> for DeserializeWith {
1162										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1163										where
1164											D: Deserializer<'de>,
1165										{
1166											Ok(DeserializeWith(serde_with::As::<
1167												serde_with::OneOrMany<serde_with::Same>,
1168											>::deserialize(deserializer)?))
1169										}
1170									}
1171									match map.next_value::<DeserializeWith>() {
1172										Ok(deserialize_with) => deserialize_with.0,
1173										Err(err) => {
1174											return Err(err);
1175										}
1176									}
1177								});
1178							}
1179							Field::DisambiguatingDescription => {
1180								if r#disambiguating_description_property.is_some() {
1181									return Err(<A::Error as de::Error>::duplicate_field(
1182										"disambiguatingDescription",
1183									));
1184								}
1185								r#disambiguating_description_property = Some({
1186									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1187									impl<'de> Deserialize<'de> for DeserializeWith {
1188										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1189										where
1190											D: Deserializer<'de>,
1191										{
1192											Ok(DeserializeWith(serde_with::As::<
1193												serde_with::OneOrMany<serde_with::Same>,
1194											>::deserialize(deserializer)?))
1195										}
1196									}
1197									match map.next_value::<DeserializeWith>() {
1198										Ok(deserialize_with) => deserialize_with.0,
1199										Err(err) => {
1200											return Err(err);
1201										}
1202									}
1203								});
1204							}
1205							Field::Identifier => {
1206								if r#identifier_property.is_some() {
1207									return Err(<A::Error as de::Error>::duplicate_field(
1208										"identifier",
1209									));
1210								}
1211								r#identifier_property = Some({
1212									struct DeserializeWith(Vec<IdentifierProperty>);
1213									impl<'de> Deserialize<'de> for DeserializeWith {
1214										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1215										where
1216											D: Deserializer<'de>,
1217										{
1218											Ok(DeserializeWith(serde_with::As::<
1219												serde_with::OneOrMany<serde_with::Same>,
1220											>::deserialize(deserializer)?))
1221										}
1222									}
1223									match map.next_value::<DeserializeWith>() {
1224										Ok(deserialize_with) => deserialize_with.0,
1225										Err(err) => {
1226											return Err(err);
1227										}
1228									}
1229								});
1230							}
1231							Field::Image => {
1232								if r#image_property.is_some() {
1233									return Err(<A::Error as de::Error>::duplicate_field("image"));
1234								}
1235								r#image_property = Some({
1236									struct DeserializeWith(Vec<ImageProperty>);
1237									impl<'de> Deserialize<'de> for DeserializeWith {
1238										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1239										where
1240											D: Deserializer<'de>,
1241										{
1242											Ok(DeserializeWith(serde_with::As::<
1243												serde_with::OneOrMany<serde_with::Same>,
1244											>::deserialize(deserializer)?))
1245										}
1246									}
1247									match map.next_value::<DeserializeWith>() {
1248										Ok(deserialize_with) => deserialize_with.0,
1249										Err(err) => {
1250											return Err(err);
1251										}
1252									}
1253								});
1254							}
1255							Field::MainEntityOfPage => {
1256								if r#main_entity_of_page_property.is_some() {
1257									return Err(<A::Error as de::Error>::duplicate_field(
1258										"mainEntityOfPage",
1259									));
1260								}
1261								r#main_entity_of_page_property = Some({
1262									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1263									impl<'de> Deserialize<'de> for DeserializeWith {
1264										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1265										where
1266											D: Deserializer<'de>,
1267										{
1268											Ok(DeserializeWith(serde_with::As::<
1269												serde_with::OneOrMany<serde_with::Same>,
1270											>::deserialize(deserializer)?))
1271										}
1272									}
1273									match map.next_value::<DeserializeWith>() {
1274										Ok(deserialize_with) => deserialize_with.0,
1275										Err(err) => {
1276											return Err(err);
1277										}
1278									}
1279								});
1280							}
1281							Field::Name => {
1282								if r#name_property.is_some() {
1283									return Err(<A::Error as de::Error>::duplicate_field("name"));
1284								}
1285								r#name_property = Some({
1286									struct DeserializeWith(Vec<NameProperty>);
1287									impl<'de> Deserialize<'de> for DeserializeWith {
1288										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1289										where
1290											D: Deserializer<'de>,
1291										{
1292											Ok(DeserializeWith(serde_with::As::<
1293												serde_with::OneOrMany<serde_with::Same>,
1294											>::deserialize(deserializer)?))
1295										}
1296									}
1297									match map.next_value::<DeserializeWith>() {
1298										Ok(deserialize_with) => deserialize_with.0,
1299										Err(err) => {
1300											return Err(err);
1301										}
1302									}
1303								});
1304							}
1305							Field::PotentialAction => {
1306								if r#potential_action_property.is_some() {
1307									return Err(<A::Error as de::Error>::duplicate_field(
1308										"potentialAction",
1309									));
1310								}
1311								r#potential_action_property = Some({
1312									struct DeserializeWith(Vec<PotentialActionProperty>);
1313									impl<'de> Deserialize<'de> for DeserializeWith {
1314										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1315										where
1316											D: Deserializer<'de>,
1317										{
1318											Ok(DeserializeWith(serde_with::As::<
1319												serde_with::OneOrMany<serde_with::Same>,
1320											>::deserialize(deserializer)?))
1321										}
1322									}
1323									match map.next_value::<DeserializeWith>() {
1324										Ok(deserialize_with) => deserialize_with.0,
1325										Err(err) => {
1326											return Err(err);
1327										}
1328									}
1329								});
1330							}
1331							Field::SameAs => {
1332								if r#same_as_property.is_some() {
1333									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1334								}
1335								r#same_as_property = Some({
1336									struct DeserializeWith(Vec<SameAsProperty>);
1337									impl<'de> Deserialize<'de> for DeserializeWith {
1338										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1339										where
1340											D: Deserializer<'de>,
1341										{
1342											Ok(DeserializeWith(serde_with::As::<
1343												serde_with::OneOrMany<serde_with::Same>,
1344											>::deserialize(deserializer)?))
1345										}
1346									}
1347									match map.next_value::<DeserializeWith>() {
1348										Ok(deserialize_with) => deserialize_with.0,
1349										Err(err) => {
1350											return Err(err);
1351										}
1352									}
1353								});
1354							}
1355							Field::SubjectOf => {
1356								if r#subject_of_property.is_some() {
1357									return Err(<A::Error as de::Error>::duplicate_field(
1358										"subjectOf",
1359									));
1360								}
1361								r#subject_of_property = Some({
1362									struct DeserializeWith(Vec<SubjectOfProperty>);
1363									impl<'de> Deserialize<'de> for DeserializeWith {
1364										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1365										where
1366											D: Deserializer<'de>,
1367										{
1368											Ok(DeserializeWith(serde_with::As::<
1369												serde_with::OneOrMany<serde_with::Same>,
1370											>::deserialize(deserializer)?))
1371										}
1372									}
1373									match map.next_value::<DeserializeWith>() {
1374										Ok(deserialize_with) => deserialize_with.0,
1375										Err(err) => {
1376											return Err(err);
1377										}
1378									}
1379								});
1380							}
1381							Field::Url => {
1382								if r#url_property.is_some() {
1383									return Err(<A::Error as de::Error>::duplicate_field("url"));
1384								}
1385								r#url_property = Some({
1386									struct DeserializeWith(Vec<UrlProperty>);
1387									impl<'de> Deserialize<'de> for DeserializeWith {
1388										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1389										where
1390											D: Deserializer<'de>,
1391										{
1392											Ok(DeserializeWith(serde_with::As::<
1393												serde_with::OneOrMany<serde_with::Same>,
1394											>::deserialize(deserializer)?))
1395										}
1396									}
1397									match map.next_value::<DeserializeWith>() {
1398										Ok(deserialize_with) => deserialize_with.0,
1399										Err(err) => {
1400											return Err(err);
1401										}
1402									}
1403								});
1404							}
1405							Field::Ignore => {
1406								let _ = map.next_value::<de::IgnoredAny>()?;
1407							}
1408						}
1409					}
1410					Ok(CompoundPriceSpecification {
1411						r#price_component: r#price_component_property.unwrap_or_default(),
1412						r#price_type: r#price_type_property.unwrap_or_default(),
1413						r#eligible_quantity: r#eligible_quantity_property.unwrap_or_default(),
1414						r#eligible_transaction_volume: r#eligible_transaction_volume_property
1415							.unwrap_or_default(),
1416						r#max_price: r#max_price_property.unwrap_or_default(),
1417						r#min_price: r#min_price_property.unwrap_or_default(),
1418						r#price: r#price_property.unwrap_or_default(),
1419						r#price_currency: r#price_currency_property.unwrap_or_default(),
1420						r#valid_from: r#valid_from_property.unwrap_or_default(),
1421						r#valid_through: r#valid_through_property.unwrap_or_default(),
1422						r#value_added_tax_included: r#value_added_tax_included_property
1423							.unwrap_or_default(),
1424						r#additional_type: r#additional_type_property.unwrap_or_default(),
1425						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1426						r#description: r#description_property.unwrap_or_default(),
1427						r#disambiguating_description: r#disambiguating_description_property
1428							.unwrap_or_default(),
1429						r#identifier: r#identifier_property.unwrap_or_default(),
1430						r#image: r#image_property.unwrap_or_default(),
1431						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1432						r#name: r#name_property.unwrap_or_default(),
1433						r#potential_action: r#potential_action_property.unwrap_or_default(),
1434						r#same_as: r#same_as_property.unwrap_or_default(),
1435						r#subject_of: r#subject_of_property.unwrap_or_default(),
1436						r#url: r#url_property.unwrap_or_default(),
1437					})
1438				}
1439			}
1440			const FIELDS: &[&str] = &[
1441				"priceComponent",
1442				"priceType",
1443				"eligibleQuantity",
1444				"eligibleTransactionVolume",
1445				"maxPrice",
1446				"minPrice",
1447				"price",
1448				"priceCurrency",
1449				"validFrom",
1450				"validThrough",
1451				"valueAddedTaxIncluded",
1452				"additionalType",
1453				"alternateName",
1454				"description",
1455				"disambiguatingDescription",
1456				"identifier",
1457				"image",
1458				"mainEntityOfPage",
1459				"name",
1460				"potentialAction",
1461				"sameAs",
1462				"subjectOf",
1463				"url",
1464			];
1465			deserializer.deserialize_struct("CompoundPriceSpecification", FIELDS, ClassVisitor)
1466		}
1467	}
1468}
schema_org_types/schemas/classes/compound_price_specification.rs

schema_org_types/schemas/classes/
compound_price_specification.rs
