use super::*;
#[cfg_attr(feature = "derive-debug", derive(Debug))]
#[cfg_attr(feature = "derive-clone", derive(Clone))]
pub struct UnitPriceSpecification {
pub r#additional_type: Vec<AdditionalTypeProperty>,
pub r#alternate_name: Vec<AlternateNameProperty>,
pub r#billing_duration: Vec<BillingDurationProperty>,
pub r#billing_increment: Vec<BillingIncrementProperty>,
pub r#billing_start: Vec<BillingStartProperty>,
pub r#description: Vec<DescriptionProperty>,
pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
pub r#eligible_quantity: Vec<EligibleQuantityProperty>,
pub r#eligible_transaction_volume: Vec<EligibleTransactionVolumeProperty>,
pub r#identifier: Vec<IdentifierProperty>,
pub r#image: Vec<ImageProperty>,
pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
pub r#max_price: Vec<MaxPriceProperty>,
pub r#min_price: Vec<MinPriceProperty>,
pub r#name: Vec<NameProperty>,
pub r#potential_action: Vec<PotentialActionProperty>,
pub r#price: Vec<PriceProperty>,
pub r#price_component_type: Vec<PriceComponentTypeProperty>,
pub r#price_currency: Vec<PriceCurrencyProperty>,
pub r#price_type: Vec<PriceTypeProperty>,
pub r#reference_quantity: Vec<ReferenceQuantityProperty>,
pub r#same_as: Vec<SameAsProperty>,
pub r#subject_of: Vec<SubjectOfProperty>,
pub r#unit_code: Vec<UnitCodeProperty>,
pub r#unit_text: Vec<UnitTextProperty>,
pub r#url: Vec<UrlProperty>,
pub r#valid_from: Vec<ValidFromProperty>,
pub r#valid_through: Vec<ValidThroughProperty>,
pub r#value_added_tax_included: Vec<ValueAddedTaxIncludedProperty>,
}
#[cfg(feature = "serde")]
mod serde {
use std::{fmt, fmt::Formatter};
use ::serde::{
de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
};
use super::*;
impl Serialize for UnitPriceSpecification {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let len: usize = [
!Vec::is_empty(&self.r#additional_type) as usize,
!Vec::is_empty(&self.r#alternate_name) as usize,
!Vec::is_empty(&self.r#billing_duration) as usize,
!Vec::is_empty(&self.r#billing_increment) as usize,
!Vec::is_empty(&self.r#billing_start) as usize,
!Vec::is_empty(&self.r#description) as usize,
!Vec::is_empty(&self.r#disambiguating_description) as usize,
!Vec::is_empty(&self.r#eligible_quantity) as usize,
!Vec::is_empty(&self.r#eligible_transaction_volume) as usize,
!Vec::is_empty(&self.r#identifier) as usize,
!Vec::is_empty(&self.r#image) as usize,
!Vec::is_empty(&self.r#main_entity_of_page) as usize,
!Vec::is_empty(&self.r#max_price) as usize,
!Vec::is_empty(&self.r#min_price) as usize,
!Vec::is_empty(&self.r#name) as usize,
!Vec::is_empty(&self.r#potential_action) as usize,
!Vec::is_empty(&self.r#price) as usize,
!Vec::is_empty(&self.r#price_component_type) as usize,
!Vec::is_empty(&self.r#price_currency) as usize,
!Vec::is_empty(&self.r#price_type) as usize,
!Vec::is_empty(&self.r#reference_quantity) as usize,
!Vec::is_empty(&self.r#same_as) as usize,
!Vec::is_empty(&self.r#subject_of) as usize,
!Vec::is_empty(&self.r#unit_code) as usize,
!Vec::is_empty(&self.r#unit_text) as usize,
!Vec::is_empty(&self.r#url) as usize,
!Vec::is_empty(&self.r#valid_from) as usize,
!Vec::is_empty(&self.r#valid_through) as usize,
!Vec::is_empty(&self.r#value_added_tax_included) as usize,
]
.iter()
.sum();
let mut serialize_struct =
Serializer::serialize_struct(serializer, "UnitPriceSpecification", len)?;
if !Vec::is_empty(&self.r#additional_type) {
serialize_struct.serialize_field("additionalType", {
struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#additional_type)
})?;
} else {
serialize_struct.skip_field("additionalType")?;
}
if !Vec::is_empty(&self.r#alternate_name) {
serialize_struct.serialize_field("alternateName", {
struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#alternate_name)
})?;
} else {
serialize_struct.skip_field("alternateName")?;
}
if !Vec::is_empty(&self.r#billing_duration) {
serialize_struct.serialize_field("billingDuration", {
struct SerializeWith<'a>(&'a Vec<BillingDurationProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#billing_duration)
})?;
} else {
serialize_struct.skip_field("billingDuration")?;
}
if !Vec::is_empty(&self.r#billing_increment) {
serialize_struct.serialize_field("billingIncrement", {
struct SerializeWith<'a>(&'a Vec<BillingIncrementProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#billing_increment)
})?;
} else {
serialize_struct.skip_field("billingIncrement")?;
}
if !Vec::is_empty(&self.r#billing_start) {
serialize_struct.serialize_field("billingStart", {
struct SerializeWith<'a>(&'a Vec<BillingStartProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#billing_start)
})?;
} else {
serialize_struct.skip_field("billingStart")?;
}
if !Vec::is_empty(&self.r#description) {
serialize_struct.serialize_field("description", {
struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#description)
})?;
} else {
serialize_struct.skip_field("description")?;
}
if !Vec::is_empty(&self.r#disambiguating_description) {
serialize_struct.serialize_field("disambiguatingDescription", {
struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#disambiguating_description)
})?;
} else {
serialize_struct.skip_field("disambiguatingDescription")?;
}
if !Vec::is_empty(&self.r#eligible_quantity) {
serialize_struct.serialize_field("eligibleQuantity", {
struct SerializeWith<'a>(&'a Vec<EligibleQuantityProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#eligible_quantity)
})?;
} else {
serialize_struct.skip_field("eligibleQuantity")?;
}
if !Vec::is_empty(&self.r#eligible_transaction_volume) {
serialize_struct.serialize_field("eligibleTransactionVolume", {
struct SerializeWith<'a>(&'a Vec<EligibleTransactionVolumeProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#eligible_transaction_volume)
})?;
} else {
serialize_struct.skip_field("eligibleTransactionVolume")?;
}
if !Vec::is_empty(&self.r#identifier) {
serialize_struct.serialize_field("identifier", {
struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#identifier)
})?;
} else {
serialize_struct.skip_field("identifier")?;
}
if !Vec::is_empty(&self.r#image) {
serialize_struct.serialize_field("image", {
struct SerializeWith<'a>(&'a Vec<ImageProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#image)
})?;
} else {
serialize_struct.skip_field("image")?;
}
if !Vec::is_empty(&self.r#main_entity_of_page) {
serialize_struct.serialize_field("mainEntityOfPage", {
struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#main_entity_of_page)
})?;
} else {
serialize_struct.skip_field("mainEntityOfPage")?;
}
if !Vec::is_empty(&self.r#max_price) {
serialize_struct.serialize_field("maxPrice", {
struct SerializeWith<'a>(&'a Vec<MaxPriceProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#max_price)
})?;
} else {
serialize_struct.skip_field("maxPrice")?;
}
if !Vec::is_empty(&self.r#min_price) {
serialize_struct.serialize_field("minPrice", {
struct SerializeWith<'a>(&'a Vec<MinPriceProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#min_price)
})?;
} else {
serialize_struct.skip_field("minPrice")?;
}
if !Vec::is_empty(&self.r#name) {
serialize_struct.serialize_field("name", {
struct SerializeWith<'a>(&'a Vec<NameProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#name)
})?;
} else {
serialize_struct.skip_field("name")?;
}
if !Vec::is_empty(&self.r#potential_action) {
serialize_struct.serialize_field("potentialAction", {
struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#potential_action)
})?;
} else {
serialize_struct.skip_field("potentialAction")?;
}
if !Vec::is_empty(&self.r#price) {
serialize_struct.serialize_field("price", {
struct SerializeWith<'a>(&'a Vec<PriceProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#price)
})?;
} else {
serialize_struct.skip_field("price")?;
}
if !Vec::is_empty(&self.r#price_component_type) {
serialize_struct.serialize_field("priceComponentType", {
struct SerializeWith<'a>(&'a Vec<PriceComponentTypeProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#price_component_type)
})?;
} else {
serialize_struct.skip_field("priceComponentType")?;
}
if !Vec::is_empty(&self.r#price_currency) {
serialize_struct.serialize_field("priceCurrency", {
struct SerializeWith<'a>(&'a Vec<PriceCurrencyProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#price_currency)
})?;
} else {
serialize_struct.skip_field("priceCurrency")?;
}
if !Vec::is_empty(&self.r#price_type) {
serialize_struct.serialize_field("priceType", {
struct SerializeWith<'a>(&'a Vec<PriceTypeProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#price_type)
})?;
} else {
serialize_struct.skip_field("priceType")?;
}
if !Vec::is_empty(&self.r#reference_quantity) {
serialize_struct.serialize_field("referenceQuantity", {
struct SerializeWith<'a>(&'a Vec<ReferenceQuantityProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#reference_quantity)
})?;
} else {
serialize_struct.skip_field("referenceQuantity")?;
}
if !Vec::is_empty(&self.r#same_as) {
serialize_struct.serialize_field("sameAs", {
struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#same_as)
})?;
} else {
serialize_struct.skip_field("sameAs")?;
}
if !Vec::is_empty(&self.r#subject_of) {
serialize_struct.serialize_field("subjectOf", {
struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#subject_of)
})?;
} else {
serialize_struct.skip_field("subjectOf")?;
}
if !Vec::is_empty(&self.r#unit_code) {
serialize_struct.serialize_field("unitCode", {
struct SerializeWith<'a>(&'a Vec<UnitCodeProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#unit_code)
})?;
} else {
serialize_struct.skip_field("unitCode")?;
}
if !Vec::is_empty(&self.r#unit_text) {
serialize_struct.serialize_field("unitText", {
struct SerializeWith<'a>(&'a Vec<UnitTextProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#unit_text)
})?;
} else {
serialize_struct.skip_field("unitText")?;
}
if !Vec::is_empty(&self.r#url) {
serialize_struct.serialize_field("url", {
struct SerializeWith<'a>(&'a Vec<UrlProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#url)
})?;
} else {
serialize_struct.skip_field("url")?;
}
if !Vec::is_empty(&self.r#valid_from) {
serialize_struct.serialize_field("validFrom", {
struct SerializeWith<'a>(&'a Vec<ValidFromProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#valid_from)
})?;
} else {
serialize_struct.skip_field("validFrom")?;
}
if !Vec::is_empty(&self.r#valid_through) {
serialize_struct.serialize_field("validThrough", {
struct SerializeWith<'a>(&'a Vec<ValidThroughProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#valid_through)
})?;
} else {
serialize_struct.skip_field("validThrough")?;
}
if !Vec::is_empty(&self.r#value_added_tax_included) {
serialize_struct.serialize_field("valueAddedTaxIncluded", {
struct SerializeWith<'a>(&'a Vec<ValueAddedTaxIncludedProperty>);
impl<'a> Serialize for SerializeWith<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
self.0, serializer,
)
}
}
&SerializeWith(&self.r#value_added_tax_included)
})?;
} else {
serialize_struct.skip_field("valueAddedTaxIncluded")?;
}
serialize_struct.end()
}
}
impl<'de> Deserialize<'de> for UnitPriceSpecification {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
enum Field {
AdditionalType,
AlternateName,
BillingDuration,
BillingIncrement,
BillingStart,
Description,
DisambiguatingDescription,
EligibleQuantity,
EligibleTransactionVolume,
Identifier,
Image,
MainEntityOfPage,
MaxPrice,
MinPrice,
Name,
PotentialAction,
Price,
PriceComponentType,
PriceCurrency,
PriceType,
ReferenceQuantity,
SameAs,
SubjectOf,
UnitCode,
UnitText,
Url,
ValidFrom,
ValidThrough,
ValueAddedTaxIncluded,
Ignore,
}
struct FieldVisitor;
impl<'de> Visitor<'de> for FieldVisitor {
type Value = Field;
fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
formatter.write_str("field identifier")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
match value {
"additionalType" => Ok(Field::AdditionalType),
"alternateName" => Ok(Field::AlternateName),
"billingDuration" => Ok(Field::BillingDuration),
"billingIncrement" => Ok(Field::BillingIncrement),
"billingStart" => Ok(Field::BillingStart),
"description" => Ok(Field::Description),
"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
"eligibleQuantity" => Ok(Field::EligibleQuantity),
"eligibleTransactionVolume" => Ok(Field::EligibleTransactionVolume),
"identifier" => Ok(Field::Identifier),
"image" => Ok(Field::Image),
"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
"maxPrice" => Ok(Field::MaxPrice),
"minPrice" => Ok(Field::MinPrice),
"name" => Ok(Field::Name),
"potentialAction" => Ok(Field::PotentialAction),
"price" => Ok(Field::Price),
"priceComponentType" => Ok(Field::PriceComponentType),
"priceCurrency" => Ok(Field::PriceCurrency),
"priceType" => Ok(Field::PriceType),
"referenceQuantity" => Ok(Field::ReferenceQuantity),
"sameAs" => Ok(Field::SameAs),
"subjectOf" => Ok(Field::SubjectOf),
"unitCode" => Ok(Field::UnitCode),
"unitText" => Ok(Field::UnitText),
"url" => Ok(Field::Url),
"validFrom" => Ok(Field::ValidFrom),
"validThrough" => Ok(Field::ValidThrough),
"valueAddedTaxIncluded" => Ok(Field::ValueAddedTaxIncluded),
_ => Ok(Field::Ignore),
}
}
fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
match value {
b"additionalType" => Ok(Field::AdditionalType),
b"alternateName" => Ok(Field::AlternateName),
b"billingDuration" => Ok(Field::BillingDuration),
b"billingIncrement" => Ok(Field::BillingIncrement),
b"billingStart" => Ok(Field::BillingStart),
b"description" => Ok(Field::Description),
b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
b"eligibleQuantity" => Ok(Field::EligibleQuantity),
b"eligibleTransactionVolume" => Ok(Field::EligibleTransactionVolume),
b"identifier" => Ok(Field::Identifier),
b"image" => Ok(Field::Image),
b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
b"maxPrice" => Ok(Field::MaxPrice),
b"minPrice" => Ok(Field::MinPrice),
b"name" => Ok(Field::Name),
b"potentialAction" => Ok(Field::PotentialAction),
b"price" => Ok(Field::Price),
b"priceComponentType" => Ok(Field::PriceComponentType),
b"priceCurrency" => Ok(Field::PriceCurrency),
b"priceType" => Ok(Field::PriceType),
b"referenceQuantity" => Ok(Field::ReferenceQuantity),
b"sameAs" => Ok(Field::SameAs),
b"subjectOf" => Ok(Field::SubjectOf),
b"unitCode" => Ok(Field::UnitCode),
b"unitText" => Ok(Field::UnitText),
b"url" => Ok(Field::Url),
b"validFrom" => Ok(Field::ValidFrom),
b"validThrough" => Ok(Field::ValidThrough),
b"valueAddedTaxIncluded" => Ok(Field::ValueAddedTaxIncluded),
_ => Ok(Field::Ignore),
}
}
}
impl<'de> Deserialize<'de> for Field {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_identifier(FieldVisitor)
}
}
struct ClassVisitor;
impl<'de> Visitor<'de> for ClassVisitor {
type Value = UnitPriceSpecification;
fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
formatter.write_str("schema.org schema UnitPriceSpecification")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: de::MapAccess<'de>,
{
let mut r#additional_type_property = None;
let mut r#alternate_name_property = None;
let mut r#billing_duration_property = None;
let mut r#billing_increment_property = None;
let mut r#billing_start_property = None;
let mut r#description_property = None;
let mut r#disambiguating_description_property = None;
let mut r#eligible_quantity_property = None;
let mut r#eligible_transaction_volume_property = None;
let mut r#identifier_property = None;
let mut r#image_property = None;
let mut r#main_entity_of_page_property = None;
let mut r#max_price_property = None;
let mut r#min_price_property = None;
let mut r#name_property = None;
let mut r#potential_action_property = None;
let mut r#price_property = None;
let mut r#price_component_type_property = None;
let mut r#price_currency_property = None;
let mut r#price_type_property = None;
let mut r#reference_quantity_property = None;
let mut r#same_as_property = None;
let mut r#subject_of_property = None;
let mut r#unit_code_property = None;
let mut r#unit_text_property = None;
let mut r#url_property = None;
let mut r#valid_from_property = None;
let mut r#valid_through_property = None;
let mut r#value_added_tax_included_property = None;
while let Some(key) = map.next_key::<Field>()? {
match key {
Field::AdditionalType => {
if r#additional_type_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"additionalType",
));
}
r#additional_type_property = Some({
struct DeserializeWith(Vec<AdditionalTypeProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::AlternateName => {
if r#alternate_name_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"alternateName",
));
}
r#alternate_name_property = Some({
struct DeserializeWith(Vec<AlternateNameProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::BillingDuration => {
if r#billing_duration_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"billingDuration",
));
}
r#billing_duration_property = Some({
struct DeserializeWith(Vec<BillingDurationProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::BillingIncrement => {
if r#billing_increment_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"billingIncrement",
));
}
r#billing_increment_property = Some({
struct DeserializeWith(Vec<BillingIncrementProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::BillingStart => {
if r#billing_start_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"billingStart",
));
}
r#billing_start_property = Some({
struct DeserializeWith(Vec<BillingStartProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Description => {
if r#description_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"description",
));
}
r#description_property = Some({
struct DeserializeWith(Vec<DescriptionProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::DisambiguatingDescription => {
if r#disambiguating_description_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"disambiguatingDescription",
));
}
r#disambiguating_description_property = Some({
struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::EligibleQuantity => {
if r#eligible_quantity_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"eligibleQuantity",
));
}
r#eligible_quantity_property = Some({
struct DeserializeWith(Vec<EligibleQuantityProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::EligibleTransactionVolume => {
if r#eligible_transaction_volume_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"eligibleTransactionVolume",
));
}
r#eligible_transaction_volume_property = Some({
struct DeserializeWith(Vec<EligibleTransactionVolumeProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Identifier => {
if r#identifier_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"identifier",
));
}
r#identifier_property = Some({
struct DeserializeWith(Vec<IdentifierProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Image => {
if r#image_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("image"));
}
r#image_property = Some({
struct DeserializeWith(Vec<ImageProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::MainEntityOfPage => {
if r#main_entity_of_page_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"mainEntityOfPage",
));
}
r#main_entity_of_page_property = Some({
struct DeserializeWith(Vec<MainEntityOfPageProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::MaxPrice => {
if r#max_price_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"maxPrice",
));
}
r#max_price_property = Some({
struct DeserializeWith(Vec<MaxPriceProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::MinPrice => {
if r#min_price_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"minPrice",
));
}
r#min_price_property = Some({
struct DeserializeWith(Vec<MinPriceProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Name => {
if r#name_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("name"));
}
r#name_property = Some({
struct DeserializeWith(Vec<NameProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::PotentialAction => {
if r#potential_action_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"potentialAction",
));
}
r#potential_action_property = Some({
struct DeserializeWith(Vec<PotentialActionProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Price => {
if r#price_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("price"));
}
r#price_property = Some({
struct DeserializeWith(Vec<PriceProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::PriceComponentType => {
if r#price_component_type_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"priceComponentType",
));
}
r#price_component_type_property = Some({
struct DeserializeWith(Vec<PriceComponentTypeProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::PriceCurrency => {
if r#price_currency_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"priceCurrency",
));
}
r#price_currency_property = Some({
struct DeserializeWith(Vec<PriceCurrencyProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::PriceType => {
if r#price_type_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"priceType",
));
}
r#price_type_property = Some({
struct DeserializeWith(Vec<PriceTypeProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::ReferenceQuantity => {
if r#reference_quantity_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"referenceQuantity",
));
}
r#reference_quantity_property = Some({
struct DeserializeWith(Vec<ReferenceQuantityProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::SameAs => {
if r#same_as_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
}
r#same_as_property = Some({
struct DeserializeWith(Vec<SameAsProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::SubjectOf => {
if r#subject_of_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"subjectOf",
));
}
r#subject_of_property = Some({
struct DeserializeWith(Vec<SubjectOfProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::UnitCode => {
if r#unit_code_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"unitCode",
));
}
r#unit_code_property = Some({
struct DeserializeWith(Vec<UnitCodeProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::UnitText => {
if r#unit_text_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"unitText",
));
}
r#unit_text_property = Some({
struct DeserializeWith(Vec<UnitTextProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::Url => {
if r#url_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field("url"));
}
r#url_property = Some({
struct DeserializeWith(Vec<UrlProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::ValidFrom => {
if r#valid_from_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"validFrom",
));
}
r#valid_from_property = Some({
struct DeserializeWith(Vec<ValidFromProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::ValidThrough => {
if r#valid_through_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"validThrough",
));
}
r#valid_through_property = Some({
struct DeserializeWith(Vec<ValidThroughProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
Field::ValueAddedTaxIncluded => {
if r#value_added_tax_included_property.is_some() {
return Err(<A::Error as de::Error>::duplicate_field(
"valueAddedTaxIncluded",
));
}
r#value_added_tax_included_property = Some({
struct DeserializeWith(Vec<ValueAddedTaxIncludedProperty>);
impl<'de> Deserialize<'de> for DeserializeWith {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(DeserializeWith(serde_with::As::<
serde_with::OneOrMany<serde_with::Same>,
>::deserialize(deserializer)?))
}
}
match map.next_value::<DeserializeWith>() {
Ok(deserialize_with) => deserialize_with.0,
Err(err) => {
return Err(err);
}
}
});
}
_ => {
let _ = map.next_value::<de::IgnoredAny>()?;
}
}
}
Ok(UnitPriceSpecification {
r#additional_type: r#additional_type_property.unwrap_or_default(),
r#alternate_name: r#alternate_name_property.unwrap_or_default(),
r#billing_duration: r#billing_duration_property.unwrap_or_default(),
r#billing_increment: r#billing_increment_property.unwrap_or_default(),
r#billing_start: r#billing_start_property.unwrap_or_default(),
r#description: r#description_property.unwrap_or_default(),
r#disambiguating_description: r#disambiguating_description_property
.unwrap_or_default(),
r#eligible_quantity: r#eligible_quantity_property.unwrap_or_default(),
r#eligible_transaction_volume: r#eligible_transaction_volume_property
.unwrap_or_default(),
r#identifier: r#identifier_property.unwrap_or_default(),
r#image: r#image_property.unwrap_or_default(),
r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
r#max_price: r#max_price_property.unwrap_or_default(),
r#min_price: r#min_price_property.unwrap_or_default(),
r#name: r#name_property.unwrap_or_default(),
r#potential_action: r#potential_action_property.unwrap_or_default(),
r#price: r#price_property.unwrap_or_default(),
r#price_component_type: r#price_component_type_property.unwrap_or_default(),
r#price_currency: r#price_currency_property.unwrap_or_default(),
r#price_type: r#price_type_property.unwrap_or_default(),
r#reference_quantity: r#reference_quantity_property.unwrap_or_default(),
r#same_as: r#same_as_property.unwrap_or_default(),
r#subject_of: r#subject_of_property.unwrap_or_default(),
r#unit_code: r#unit_code_property.unwrap_or_default(),
r#unit_text: r#unit_text_property.unwrap_or_default(),
r#url: r#url_property.unwrap_or_default(),
r#valid_from: r#valid_from_property.unwrap_or_default(),
r#valid_through: r#valid_through_property.unwrap_or_default(),
r#value_added_tax_included: r#value_added_tax_included_property
.unwrap_or_default(),
})
}
}
const FIELDS: &[&str] = &[
"additionalType",
"alternateName",
"billingDuration",
"billingIncrement",
"billingStart",
"description",
"disambiguatingDescription",
"eligibleQuantity",
"eligibleTransactionVolume",
"identifier",
"image",
"mainEntityOfPage",
"maxPrice",
"minPrice",
"name",
"potentialAction",
"price",
"priceComponentType",
"priceCurrency",
"priceType",
"referenceQuantity",
"sameAs",
"subjectOf",
"unitCode",
"unitText",
"url",
"validFrom",
"validThrough",
"valueAddedTaxIncluded",
];
deserializer.deserialize_struct("UnitPriceSpecification", FIELDS, ClassVisitor)
}
}
}