1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct UnitPriceSpecification {
6 pub r#billing_duration: Vec<BillingDurationProperty>,
8 pub r#billing_increment: Vec<BillingIncrementProperty>,
10 pub r#billing_start: Vec<BillingStartProperty>,
12 pub r#price_component_type: Vec<PriceComponentTypeProperty>,
14 pub r#price_type: Vec<PriceTypeProperty>,
16 pub r#reference_quantity: Vec<ReferenceQuantityProperty>,
18 pub r#unit_code: Vec<UnitCodeProperty>,
20 pub r#unit_text: Vec<UnitTextProperty>,
22 pub r#eligible_quantity: Vec<EligibleQuantityProperty>,
24 pub r#eligible_transaction_volume: Vec<EligibleTransactionVolumeProperty>,
26 pub r#max_price: Vec<MaxPriceProperty>,
28 pub r#min_price: Vec<MinPriceProperty>,
30 pub r#price: Vec<PriceProperty>,
32 pub r#price_currency: Vec<PriceCurrencyProperty>,
34 pub r#valid_from: Vec<ValidFromProperty>,
36 pub r#valid_through: Vec<ValidThroughProperty>,
38 pub r#value_added_tax_included: Vec<ValueAddedTaxIncludedProperty>,
40 pub r#additional_type: Vec<AdditionalTypeProperty>,
42 pub r#alternate_name: Vec<AlternateNameProperty>,
44 pub r#description: Vec<DescriptionProperty>,
46 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
48 pub r#identifier: Vec<IdentifierProperty>,
50 pub r#image: Vec<ImageProperty>,
52 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
54 pub r#name: Vec<NameProperty>,
56 pub r#potential_action: Vec<PotentialActionProperty>,
58 pub r#same_as: Vec<SameAsProperty>,
60 pub r#subject_of: Vec<SubjectOfProperty>,
62 pub r#url: Vec<UrlProperty>,
64}
65pub trait UnitPriceSpecificationTrait {
67 fn get_billing_duration(&self) -> &[BillingDurationProperty];
69 fn take_billing_duration(&mut self) -> Vec<BillingDurationProperty>;
71 fn get_billing_increment(&self) -> &[BillingIncrementProperty];
73 fn take_billing_increment(&mut self) -> Vec<BillingIncrementProperty>;
75 fn get_billing_start(&self) -> &[BillingStartProperty];
77 fn take_billing_start(&mut self) -> Vec<BillingStartProperty>;
79 fn get_price_component_type(&self) -> &[PriceComponentTypeProperty];
81 fn take_price_component_type(&mut self) -> Vec<PriceComponentTypeProperty>;
83 fn get_price_type(&self) -> &[PriceTypeProperty];
85 fn take_price_type(&mut self) -> Vec<PriceTypeProperty>;
87 fn get_reference_quantity(&self) -> &[ReferenceQuantityProperty];
89 fn take_reference_quantity(&mut self) -> Vec<ReferenceQuantityProperty>;
91 fn get_unit_code(&self) -> &[UnitCodeProperty];
93 fn take_unit_code(&mut self) -> Vec<UnitCodeProperty>;
95 fn get_unit_text(&self) -> &[UnitTextProperty];
97 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}