schema_org_types/schemas/classes/
shipping_delivery_time.rs

1use super::*;
2/// <https://schema.org/ShippingDeliveryTime>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct ShippingDeliveryTime {
6	/// <https://schema.org/businessDays>
7	pub r#business_days: Vec<BusinessDaysProperty>,
8	/// <https://schema.org/cutoffTime>
9	pub r#cutoff_time: Vec<CutoffTimeProperty>,
10	/// <https://schema.org/handlingTime>
11	pub r#handling_time: Vec<HandlingTimeProperty>,
12	/// <https://schema.org/transitTime>
13	pub r#transit_time: Vec<TransitTimeProperty>,
14	/// <https://schema.org/additionalType>
15	pub r#additional_type: Vec<AdditionalTypeProperty>,
16	/// <https://schema.org/alternateName>
17	pub r#alternate_name: Vec<AlternateNameProperty>,
18	/// <https://schema.org/description>
19	pub r#description: Vec<DescriptionProperty>,
20	/// <https://schema.org/disambiguatingDescription>
21	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
22	/// <https://schema.org/identifier>
23	pub r#identifier: Vec<IdentifierProperty>,
24	/// <https://schema.org/image>
25	pub r#image: Vec<ImageProperty>,
26	/// <https://schema.org/mainEntityOfPage>
27	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
28	/// <https://schema.org/name>
29	pub r#name: Vec<NameProperty>,
30	/// <https://schema.org/potentialAction>
31	pub r#potential_action: Vec<PotentialActionProperty>,
32	/// <https://schema.org/sameAs>
33	pub r#same_as: Vec<SameAsProperty>,
34	/// <https://schema.org/subjectOf>
35	pub r#subject_of: Vec<SubjectOfProperty>,
36	/// <https://schema.org/url>
37	pub r#url: Vec<UrlProperty>,
38}
39/// This trait is for properties from <https://schema.org/ShippingDeliveryTime>.
40pub trait ShippingDeliveryTimeTrait {
41	/// Get <https://schema.org/businessDays> from [`Self`] as borrowed slice.
42	fn get_business_days(&self) -> &[BusinessDaysProperty];
43	/// Take <https://schema.org/businessDays> from [`Self`] as owned vector.
44	fn take_business_days(&mut self) -> Vec<BusinessDaysProperty>;
45	/// Get <https://schema.org/cutoffTime> from [`Self`] as borrowed slice.
46	fn get_cutoff_time(&self) -> &[CutoffTimeProperty];
47	/// Take <https://schema.org/cutoffTime> from [`Self`] as owned vector.
48	fn take_cutoff_time(&mut self) -> Vec<CutoffTimeProperty>;
49	/// Get <https://schema.org/handlingTime> from [`Self`] as borrowed slice.
50	fn get_handling_time(&self) -> &[HandlingTimeProperty];
51	/// Take <https://schema.org/handlingTime> from [`Self`] as owned vector.
52	fn take_handling_time(&mut self) -> Vec<HandlingTimeProperty>;
53	/// Get <https://schema.org/transitTime> from [`Self`] as borrowed slice.
54	fn get_transit_time(&self) -> &[TransitTimeProperty];
55	/// Take <https://schema.org/transitTime> from [`Self`] as owned vector.
56	fn take_transit_time(&mut self) -> Vec<TransitTimeProperty>;
57}
58impl ShippingDeliveryTimeTrait for ShippingDeliveryTime {
59	fn get_business_days(&self) -> &[BusinessDaysProperty] {
60		self.r#business_days.as_slice()
61	}
62	fn take_business_days(&mut self) -> Vec<BusinessDaysProperty> {
63		std::mem::take(&mut self.r#business_days)
64	}
65	fn get_cutoff_time(&self) -> &[CutoffTimeProperty] {
66		self.r#cutoff_time.as_slice()
67	}
68	fn take_cutoff_time(&mut self) -> Vec<CutoffTimeProperty> {
69		std::mem::take(&mut self.r#cutoff_time)
70	}
71	fn get_handling_time(&self) -> &[HandlingTimeProperty] {
72		self.r#handling_time.as_slice()
73	}
74	fn take_handling_time(&mut self) -> Vec<HandlingTimeProperty> {
75		std::mem::take(&mut self.r#handling_time)
76	}
77	fn get_transit_time(&self) -> &[TransitTimeProperty] {
78		self.r#transit_time.as_slice()
79	}
80	fn take_transit_time(&mut self) -> Vec<TransitTimeProperty> {
81		std::mem::take(&mut self.r#transit_time)
82	}
83}
84impl StructuredValueTrait for ShippingDeliveryTime {}
85impl ThingTrait for ShippingDeliveryTime {
86	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
87		self.r#additional_type.as_slice()
88	}
89	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
90		std::mem::take(&mut self.r#additional_type)
91	}
92	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
93		self.r#alternate_name.as_slice()
94	}
95	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
96		std::mem::take(&mut self.r#alternate_name)
97	}
98	fn get_description(&self) -> &[DescriptionProperty] {
99		self.r#description.as_slice()
100	}
101	fn take_description(&mut self) -> Vec<DescriptionProperty> {
102		std::mem::take(&mut self.r#description)
103	}
104	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
105		self.r#disambiguating_description.as_slice()
106	}
107	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
108		std::mem::take(&mut self.r#disambiguating_description)
109	}
110	fn get_identifier(&self) -> &[IdentifierProperty] {
111		self.r#identifier.as_slice()
112	}
113	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
114		std::mem::take(&mut self.r#identifier)
115	}
116	fn get_image(&self) -> &[ImageProperty] {
117		self.r#image.as_slice()
118	}
119	fn take_image(&mut self) -> Vec<ImageProperty> {
120		std::mem::take(&mut self.r#image)
121	}
122	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
123		self.r#main_entity_of_page.as_slice()
124	}
125	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
126		std::mem::take(&mut self.r#main_entity_of_page)
127	}
128	fn get_name(&self) -> &[NameProperty] {
129		self.r#name.as_slice()
130	}
131	fn take_name(&mut self) -> Vec<NameProperty> {
132		std::mem::take(&mut self.r#name)
133	}
134	fn get_potential_action(&self) -> &[PotentialActionProperty] {
135		self.r#potential_action.as_slice()
136	}
137	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
138		std::mem::take(&mut self.r#potential_action)
139	}
140	fn get_same_as(&self) -> &[SameAsProperty] {
141		self.r#same_as.as_slice()
142	}
143	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
144		std::mem::take(&mut self.r#same_as)
145	}
146	fn get_subject_of(&self) -> &[SubjectOfProperty] {
147		self.r#subject_of.as_slice()
148	}
149	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
150		std::mem::take(&mut self.r#subject_of)
151	}
152	fn get_url(&self) -> &[UrlProperty] {
153		self.r#url.as_slice()
154	}
155	fn take_url(&mut self) -> Vec<UrlProperty> {
156		std::mem::take(&mut self.r#url)
157	}
158}
159#[cfg(feature = "serde")]
160mod serde {
161	use std::{fmt, fmt::Formatter};
162
163	use ::serde::{
164		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
165	};
166
167	use super::*;
168	impl Serialize for ShippingDeliveryTime {
169		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
170		where
171			S: Serializer,
172		{
173			let len: usize = [
174				!Vec::is_empty(&self.r#business_days) as usize,
175				!Vec::is_empty(&self.r#cutoff_time) as usize,
176				!Vec::is_empty(&self.r#handling_time) as usize,
177				!Vec::is_empty(&self.r#transit_time) as usize,
178				!Vec::is_empty(&self.r#additional_type) as usize,
179				!Vec::is_empty(&self.r#alternate_name) as usize,
180				!Vec::is_empty(&self.r#description) as usize,
181				!Vec::is_empty(&self.r#disambiguating_description) as usize,
182				!Vec::is_empty(&self.r#identifier) as usize,
183				!Vec::is_empty(&self.r#image) as usize,
184				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
185				!Vec::is_empty(&self.r#name) as usize,
186				!Vec::is_empty(&self.r#potential_action) as usize,
187				!Vec::is_empty(&self.r#same_as) as usize,
188				!Vec::is_empty(&self.r#subject_of) as usize,
189				!Vec::is_empty(&self.r#url) as usize,
190			]
191			.iter()
192			.sum();
193			let mut serialize_struct =
194				Serializer::serialize_struct(serializer, "ShippingDeliveryTime", len)?;
195			if !Vec::is_empty(&self.r#business_days) {
196				serialize_struct.serialize_field("businessDays", {
197					struct SerializeWith<'a>(&'a Vec<BusinessDaysProperty>);
198					impl<'a> Serialize for SerializeWith<'a> {
199						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
200						where
201							S: Serializer,
202						{
203							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
204								self.0, serializer,
205							)
206						}
207					}
208					&SerializeWith(&self.r#business_days)
209				})?;
210			} else {
211				serialize_struct.skip_field("businessDays")?;
212			}
213			if !Vec::is_empty(&self.r#cutoff_time) {
214				serialize_struct.serialize_field("cutoffTime", {
215					struct SerializeWith<'a>(&'a Vec<CutoffTimeProperty>);
216					impl<'a> Serialize for SerializeWith<'a> {
217						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
218						where
219							S: Serializer,
220						{
221							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
222								self.0, serializer,
223							)
224						}
225					}
226					&SerializeWith(&self.r#cutoff_time)
227				})?;
228			} else {
229				serialize_struct.skip_field("cutoffTime")?;
230			}
231			if !Vec::is_empty(&self.r#handling_time) {
232				serialize_struct.serialize_field("handlingTime", {
233					struct SerializeWith<'a>(&'a Vec<HandlingTimeProperty>);
234					impl<'a> Serialize for SerializeWith<'a> {
235						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
236						where
237							S: Serializer,
238						{
239							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
240								self.0, serializer,
241							)
242						}
243					}
244					&SerializeWith(&self.r#handling_time)
245				})?;
246			} else {
247				serialize_struct.skip_field("handlingTime")?;
248			}
249			if !Vec::is_empty(&self.r#transit_time) {
250				serialize_struct.serialize_field("transitTime", {
251					struct SerializeWith<'a>(&'a Vec<TransitTimeProperty>);
252					impl<'a> Serialize for SerializeWith<'a> {
253						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
254						where
255							S: Serializer,
256						{
257							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
258								self.0, serializer,
259							)
260						}
261					}
262					&SerializeWith(&self.r#transit_time)
263				})?;
264			} else {
265				serialize_struct.skip_field("transitTime")?;
266			}
267			if !Vec::is_empty(&self.r#additional_type) {
268				serialize_struct.serialize_field("additionalType", {
269					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
270					impl<'a> Serialize for SerializeWith<'a> {
271						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
272						where
273							S: Serializer,
274						{
275							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
276								self.0, serializer,
277							)
278						}
279					}
280					&SerializeWith(&self.r#additional_type)
281				})?;
282			} else {
283				serialize_struct.skip_field("additionalType")?;
284			}
285			if !Vec::is_empty(&self.r#alternate_name) {
286				serialize_struct.serialize_field("alternateName", {
287					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
288					impl<'a> Serialize for SerializeWith<'a> {
289						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
290						where
291							S: Serializer,
292						{
293							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
294								self.0, serializer,
295							)
296						}
297					}
298					&SerializeWith(&self.r#alternate_name)
299				})?;
300			} else {
301				serialize_struct.skip_field("alternateName")?;
302			}
303			if !Vec::is_empty(&self.r#description) {
304				serialize_struct.serialize_field("description", {
305					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
306					impl<'a> Serialize for SerializeWith<'a> {
307						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
308						where
309							S: Serializer,
310						{
311							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
312								self.0, serializer,
313							)
314						}
315					}
316					&SerializeWith(&self.r#description)
317				})?;
318			} else {
319				serialize_struct.skip_field("description")?;
320			}
321			if !Vec::is_empty(&self.r#disambiguating_description) {
322				serialize_struct.serialize_field("disambiguatingDescription", {
323					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
324					impl<'a> Serialize for SerializeWith<'a> {
325						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
326						where
327							S: Serializer,
328						{
329							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
330								self.0, serializer,
331							)
332						}
333					}
334					&SerializeWith(&self.r#disambiguating_description)
335				})?;
336			} else {
337				serialize_struct.skip_field("disambiguatingDescription")?;
338			}
339			if !Vec::is_empty(&self.r#identifier) {
340				serialize_struct.serialize_field("identifier", {
341					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
342					impl<'a> Serialize for SerializeWith<'a> {
343						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
344						where
345							S: Serializer,
346						{
347							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
348								self.0, serializer,
349							)
350						}
351					}
352					&SerializeWith(&self.r#identifier)
353				})?;
354			} else {
355				serialize_struct.skip_field("identifier")?;
356			}
357			if !Vec::is_empty(&self.r#image) {
358				serialize_struct.serialize_field("image", {
359					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
360					impl<'a> Serialize for SerializeWith<'a> {
361						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
362						where
363							S: Serializer,
364						{
365							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
366								self.0, serializer,
367							)
368						}
369					}
370					&SerializeWith(&self.r#image)
371				})?;
372			} else {
373				serialize_struct.skip_field("image")?;
374			}
375			if !Vec::is_empty(&self.r#main_entity_of_page) {
376				serialize_struct.serialize_field("mainEntityOfPage", {
377					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
378					impl<'a> Serialize for SerializeWith<'a> {
379						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
380						where
381							S: Serializer,
382						{
383							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
384								self.0, serializer,
385							)
386						}
387					}
388					&SerializeWith(&self.r#main_entity_of_page)
389				})?;
390			} else {
391				serialize_struct.skip_field("mainEntityOfPage")?;
392			}
393			if !Vec::is_empty(&self.r#name) {
394				serialize_struct.serialize_field("name", {
395					struct SerializeWith<'a>(&'a Vec<NameProperty>);
396					impl<'a> Serialize for SerializeWith<'a> {
397						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
398						where
399							S: Serializer,
400						{
401							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
402								self.0, serializer,
403							)
404						}
405					}
406					&SerializeWith(&self.r#name)
407				})?;
408			} else {
409				serialize_struct.skip_field("name")?;
410			}
411			if !Vec::is_empty(&self.r#potential_action) {
412				serialize_struct.serialize_field("potentialAction", {
413					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
414					impl<'a> Serialize for SerializeWith<'a> {
415						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
416						where
417							S: Serializer,
418						{
419							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
420								self.0, serializer,
421							)
422						}
423					}
424					&SerializeWith(&self.r#potential_action)
425				})?;
426			} else {
427				serialize_struct.skip_field("potentialAction")?;
428			}
429			if !Vec::is_empty(&self.r#same_as) {
430				serialize_struct.serialize_field("sameAs", {
431					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
432					impl<'a> Serialize for SerializeWith<'a> {
433						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
434						where
435							S: Serializer,
436						{
437							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
438								self.0, serializer,
439							)
440						}
441					}
442					&SerializeWith(&self.r#same_as)
443				})?;
444			} else {
445				serialize_struct.skip_field("sameAs")?;
446			}
447			if !Vec::is_empty(&self.r#subject_of) {
448				serialize_struct.serialize_field("subjectOf", {
449					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
450					impl<'a> Serialize for SerializeWith<'a> {
451						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
452						where
453							S: Serializer,
454						{
455							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
456								self.0, serializer,
457							)
458						}
459					}
460					&SerializeWith(&self.r#subject_of)
461				})?;
462			} else {
463				serialize_struct.skip_field("subjectOf")?;
464			}
465			if !Vec::is_empty(&self.r#url) {
466				serialize_struct.serialize_field("url", {
467					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
468					impl<'a> Serialize for SerializeWith<'a> {
469						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
470						where
471							S: Serializer,
472						{
473							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
474								self.0, serializer,
475							)
476						}
477					}
478					&SerializeWith(&self.r#url)
479				})?;
480			} else {
481				serialize_struct.skip_field("url")?;
482			}
483			serialize_struct.end()
484		}
485	}
486	impl<'de> Deserialize<'de> for ShippingDeliveryTime {
487		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
488		where
489			D: Deserializer<'de>,
490		{
491			enum Field {
492				BusinessDays,
493				CutoffTime,
494				HandlingTime,
495				TransitTime,
496				AdditionalType,
497				AlternateName,
498				Description,
499				DisambiguatingDescription,
500				Identifier,
501				Image,
502				MainEntityOfPage,
503				Name,
504				PotentialAction,
505				SameAs,
506				SubjectOf,
507				Url,
508				Ignore,
509			}
510			struct FieldVisitor;
511			impl<'de> Visitor<'de> for FieldVisitor {
512				type Value = Field;
513				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
514					formatter.write_str("field identifier")
515				}
516				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
517				where
518					E: de::Error,
519				{
520					match value {
521						"businessDays" => Ok(Field::BusinessDays),
522						"cutoffTime" => Ok(Field::CutoffTime),
523						"handlingTime" => Ok(Field::HandlingTime),
524						"transitTime" => Ok(Field::TransitTime),
525						"additionalType" => Ok(Field::AdditionalType),
526						"alternateName" => Ok(Field::AlternateName),
527						"description" => Ok(Field::Description),
528						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
529						"identifier" => Ok(Field::Identifier),
530						"image" => Ok(Field::Image),
531						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
532						"name" => Ok(Field::Name),
533						"potentialAction" => Ok(Field::PotentialAction),
534						"sameAs" => Ok(Field::SameAs),
535						"subjectOf" => Ok(Field::SubjectOf),
536						"url" => Ok(Field::Url),
537						"id" | "type" => Ok(Field::Ignore),
538						_ => Err(de::Error::unknown_field(value, FIELDS)),
539					}
540				}
541				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
542				where
543					E: de::Error,
544				{
545					match value {
546						b"businessDays" => Ok(Field::BusinessDays),
547						b"cutoffTime" => Ok(Field::CutoffTime),
548						b"handlingTime" => Ok(Field::HandlingTime),
549						b"transitTime" => Ok(Field::TransitTime),
550						b"additionalType" => Ok(Field::AdditionalType),
551						b"alternateName" => Ok(Field::AlternateName),
552						b"description" => Ok(Field::Description),
553						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
554						b"identifier" => Ok(Field::Identifier),
555						b"image" => Ok(Field::Image),
556						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
557						b"name" => Ok(Field::Name),
558						b"potentialAction" => Ok(Field::PotentialAction),
559						b"sameAs" => Ok(Field::SameAs),
560						b"subjectOf" => Ok(Field::SubjectOf),
561						b"url" => Ok(Field::Url),
562						b"id" | b"type" => Ok(Field::Ignore),
563						_ => {
564							let value = &String::from_utf8_lossy(value);
565							Err(de::Error::unknown_field(value, FIELDS))
566						}
567					}
568				}
569			}
570			impl<'de> Deserialize<'de> for Field {
571				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
572				where
573					D: Deserializer<'de>,
574				{
575					deserializer.deserialize_identifier(FieldVisitor)
576				}
577			}
578			struct ClassVisitor;
579			impl<'de> Visitor<'de> for ClassVisitor {
580				type Value = ShippingDeliveryTime;
581				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
582					formatter.write_str("schema.org schema ShippingDeliveryTime")
583				}
584				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
585				where
586					A: de::MapAccess<'de>,
587				{
588					let mut r#business_days_property = None;
589					let mut r#cutoff_time_property = None;
590					let mut r#handling_time_property = None;
591					let mut r#transit_time_property = None;
592					let mut r#additional_type_property = None;
593					let mut r#alternate_name_property = None;
594					let mut r#description_property = None;
595					let mut r#disambiguating_description_property = None;
596					let mut r#identifier_property = None;
597					let mut r#image_property = None;
598					let mut r#main_entity_of_page_property = None;
599					let mut r#name_property = None;
600					let mut r#potential_action_property = None;
601					let mut r#same_as_property = None;
602					let mut r#subject_of_property = None;
603					let mut r#url_property = None;
604					while let Some(key) = map.next_key::<Field>()? {
605						match key {
606							Field::BusinessDays => {
607								if r#business_days_property.is_some() {
608									return Err(<A::Error as de::Error>::duplicate_field(
609										"businessDays",
610									));
611								}
612								r#business_days_property = Some({
613									struct DeserializeWith(Vec<BusinessDaysProperty>);
614									impl<'de> Deserialize<'de> for DeserializeWith {
615										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
616										where
617											D: Deserializer<'de>,
618										{
619											Ok(DeserializeWith(serde_with::As::<
620												serde_with::OneOrMany<serde_with::Same>,
621											>::deserialize(deserializer)?))
622										}
623									}
624									match map.next_value::<DeserializeWith>() {
625										Ok(deserialize_with) => deserialize_with.0,
626										Err(err) => {
627											return Err(err);
628										}
629									}
630								});
631							}
632							Field::CutoffTime => {
633								if r#cutoff_time_property.is_some() {
634									return Err(<A::Error as de::Error>::duplicate_field(
635										"cutoffTime",
636									));
637								}
638								r#cutoff_time_property = Some({
639									struct DeserializeWith(Vec<CutoffTimeProperty>);
640									impl<'de> Deserialize<'de> for DeserializeWith {
641										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
642										where
643											D: Deserializer<'de>,
644										{
645											Ok(DeserializeWith(serde_with::As::<
646												serde_with::OneOrMany<serde_with::Same>,
647											>::deserialize(deserializer)?))
648										}
649									}
650									match map.next_value::<DeserializeWith>() {
651										Ok(deserialize_with) => deserialize_with.0,
652										Err(err) => {
653											return Err(err);
654										}
655									}
656								});
657							}
658							Field::HandlingTime => {
659								if r#handling_time_property.is_some() {
660									return Err(<A::Error as de::Error>::duplicate_field(
661										"handlingTime",
662									));
663								}
664								r#handling_time_property = Some({
665									struct DeserializeWith(Vec<HandlingTimeProperty>);
666									impl<'de> Deserialize<'de> for DeserializeWith {
667										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
668										where
669											D: Deserializer<'de>,
670										{
671											Ok(DeserializeWith(serde_with::As::<
672												serde_with::OneOrMany<serde_with::Same>,
673											>::deserialize(deserializer)?))
674										}
675									}
676									match map.next_value::<DeserializeWith>() {
677										Ok(deserialize_with) => deserialize_with.0,
678										Err(err) => {
679											return Err(err);
680										}
681									}
682								});
683							}
684							Field::TransitTime => {
685								if r#transit_time_property.is_some() {
686									return Err(<A::Error as de::Error>::duplicate_field(
687										"transitTime",
688									));
689								}
690								r#transit_time_property = Some({
691									struct DeserializeWith(Vec<TransitTimeProperty>);
692									impl<'de> Deserialize<'de> for DeserializeWith {
693										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
694										where
695											D: Deserializer<'de>,
696										{
697											Ok(DeserializeWith(serde_with::As::<
698												serde_with::OneOrMany<serde_with::Same>,
699											>::deserialize(deserializer)?))
700										}
701									}
702									match map.next_value::<DeserializeWith>() {
703										Ok(deserialize_with) => deserialize_with.0,
704										Err(err) => {
705											return Err(err);
706										}
707									}
708								});
709							}
710							Field::AdditionalType => {
711								if r#additional_type_property.is_some() {
712									return Err(<A::Error as de::Error>::duplicate_field(
713										"additionalType",
714									));
715								}
716								r#additional_type_property = Some({
717									struct DeserializeWith(Vec<AdditionalTypeProperty>);
718									impl<'de> Deserialize<'de> for DeserializeWith {
719										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
720										where
721											D: Deserializer<'de>,
722										{
723											Ok(DeserializeWith(serde_with::As::<
724												serde_with::OneOrMany<serde_with::Same>,
725											>::deserialize(deserializer)?))
726										}
727									}
728									match map.next_value::<DeserializeWith>() {
729										Ok(deserialize_with) => deserialize_with.0,
730										Err(err) => {
731											return Err(err);
732										}
733									}
734								});
735							}
736							Field::AlternateName => {
737								if r#alternate_name_property.is_some() {
738									return Err(<A::Error as de::Error>::duplicate_field(
739										"alternateName",
740									));
741								}
742								r#alternate_name_property = Some({
743									struct DeserializeWith(Vec<AlternateNameProperty>);
744									impl<'de> Deserialize<'de> for DeserializeWith {
745										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
746										where
747											D: Deserializer<'de>,
748										{
749											Ok(DeserializeWith(serde_with::As::<
750												serde_with::OneOrMany<serde_with::Same>,
751											>::deserialize(deserializer)?))
752										}
753									}
754									match map.next_value::<DeserializeWith>() {
755										Ok(deserialize_with) => deserialize_with.0,
756										Err(err) => {
757											return Err(err);
758										}
759									}
760								});
761							}
762							Field::Description => {
763								if r#description_property.is_some() {
764									return Err(<A::Error as de::Error>::duplicate_field(
765										"description",
766									));
767								}
768								r#description_property = Some({
769									struct DeserializeWith(Vec<DescriptionProperty>);
770									impl<'de> Deserialize<'de> for DeserializeWith {
771										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
772										where
773											D: Deserializer<'de>,
774										{
775											Ok(DeserializeWith(serde_with::As::<
776												serde_with::OneOrMany<serde_with::Same>,
777											>::deserialize(deserializer)?))
778										}
779									}
780									match map.next_value::<DeserializeWith>() {
781										Ok(deserialize_with) => deserialize_with.0,
782										Err(err) => {
783											return Err(err);
784										}
785									}
786								});
787							}
788							Field::DisambiguatingDescription => {
789								if r#disambiguating_description_property.is_some() {
790									return Err(<A::Error as de::Error>::duplicate_field(
791										"disambiguatingDescription",
792									));
793								}
794								r#disambiguating_description_property = Some({
795									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
796									impl<'de> Deserialize<'de> for DeserializeWith {
797										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
798										where
799											D: Deserializer<'de>,
800										{
801											Ok(DeserializeWith(serde_with::As::<
802												serde_with::OneOrMany<serde_with::Same>,
803											>::deserialize(deserializer)?))
804										}
805									}
806									match map.next_value::<DeserializeWith>() {
807										Ok(deserialize_with) => deserialize_with.0,
808										Err(err) => {
809											return Err(err);
810										}
811									}
812								});
813							}
814							Field::Identifier => {
815								if r#identifier_property.is_some() {
816									return Err(<A::Error as de::Error>::duplicate_field(
817										"identifier",
818									));
819								}
820								r#identifier_property = Some({
821									struct DeserializeWith(Vec<IdentifierProperty>);
822									impl<'de> Deserialize<'de> for DeserializeWith {
823										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
824										where
825											D: Deserializer<'de>,
826										{
827											Ok(DeserializeWith(serde_with::As::<
828												serde_with::OneOrMany<serde_with::Same>,
829											>::deserialize(deserializer)?))
830										}
831									}
832									match map.next_value::<DeserializeWith>() {
833										Ok(deserialize_with) => deserialize_with.0,
834										Err(err) => {
835											return Err(err);
836										}
837									}
838								});
839							}
840							Field::Image => {
841								if r#image_property.is_some() {
842									return Err(<A::Error as de::Error>::duplicate_field("image"));
843								}
844								r#image_property = Some({
845									struct DeserializeWith(Vec<ImageProperty>);
846									impl<'de> Deserialize<'de> for DeserializeWith {
847										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
848										where
849											D: Deserializer<'de>,
850										{
851											Ok(DeserializeWith(serde_with::As::<
852												serde_with::OneOrMany<serde_with::Same>,
853											>::deserialize(deserializer)?))
854										}
855									}
856									match map.next_value::<DeserializeWith>() {
857										Ok(deserialize_with) => deserialize_with.0,
858										Err(err) => {
859											return Err(err);
860										}
861									}
862								});
863							}
864							Field::MainEntityOfPage => {
865								if r#main_entity_of_page_property.is_some() {
866									return Err(<A::Error as de::Error>::duplicate_field(
867										"mainEntityOfPage",
868									));
869								}
870								r#main_entity_of_page_property = Some({
871									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
872									impl<'de> Deserialize<'de> for DeserializeWith {
873										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
874										where
875											D: Deserializer<'de>,
876										{
877											Ok(DeserializeWith(serde_with::As::<
878												serde_with::OneOrMany<serde_with::Same>,
879											>::deserialize(deserializer)?))
880										}
881									}
882									match map.next_value::<DeserializeWith>() {
883										Ok(deserialize_with) => deserialize_with.0,
884										Err(err) => {
885											return Err(err);
886										}
887									}
888								});
889							}
890							Field::Name => {
891								if r#name_property.is_some() {
892									return Err(<A::Error as de::Error>::duplicate_field("name"));
893								}
894								r#name_property = Some({
895									struct DeserializeWith(Vec<NameProperty>);
896									impl<'de> Deserialize<'de> for DeserializeWith {
897										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
898										where
899											D: Deserializer<'de>,
900										{
901											Ok(DeserializeWith(serde_with::As::<
902												serde_with::OneOrMany<serde_with::Same>,
903											>::deserialize(deserializer)?))
904										}
905									}
906									match map.next_value::<DeserializeWith>() {
907										Ok(deserialize_with) => deserialize_with.0,
908										Err(err) => {
909											return Err(err);
910										}
911									}
912								});
913							}
914							Field::PotentialAction => {
915								if r#potential_action_property.is_some() {
916									return Err(<A::Error as de::Error>::duplicate_field(
917										"potentialAction",
918									));
919								}
920								r#potential_action_property = Some({
921									struct DeserializeWith(Vec<PotentialActionProperty>);
922									impl<'de> Deserialize<'de> for DeserializeWith {
923										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
924										where
925											D: Deserializer<'de>,
926										{
927											Ok(DeserializeWith(serde_with::As::<
928												serde_with::OneOrMany<serde_with::Same>,
929											>::deserialize(deserializer)?))
930										}
931									}
932									match map.next_value::<DeserializeWith>() {
933										Ok(deserialize_with) => deserialize_with.0,
934										Err(err) => {
935											return Err(err);
936										}
937									}
938								});
939							}
940							Field::SameAs => {
941								if r#same_as_property.is_some() {
942									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
943								}
944								r#same_as_property = Some({
945									struct DeserializeWith(Vec<SameAsProperty>);
946									impl<'de> Deserialize<'de> for DeserializeWith {
947										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
948										where
949											D: Deserializer<'de>,
950										{
951											Ok(DeserializeWith(serde_with::As::<
952												serde_with::OneOrMany<serde_with::Same>,
953											>::deserialize(deserializer)?))
954										}
955									}
956									match map.next_value::<DeserializeWith>() {
957										Ok(deserialize_with) => deserialize_with.0,
958										Err(err) => {
959											return Err(err);
960										}
961									}
962								});
963							}
964							Field::SubjectOf => {
965								if r#subject_of_property.is_some() {
966									return Err(<A::Error as de::Error>::duplicate_field(
967										"subjectOf",
968									));
969								}
970								r#subject_of_property = Some({
971									struct DeserializeWith(Vec<SubjectOfProperty>);
972									impl<'de> Deserialize<'de> for DeserializeWith {
973										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
974										where
975											D: Deserializer<'de>,
976										{
977											Ok(DeserializeWith(serde_with::As::<
978												serde_with::OneOrMany<serde_with::Same>,
979											>::deserialize(deserializer)?))
980										}
981									}
982									match map.next_value::<DeserializeWith>() {
983										Ok(deserialize_with) => deserialize_with.0,
984										Err(err) => {
985											return Err(err);
986										}
987									}
988								});
989							}
990							Field::Url => {
991								if r#url_property.is_some() {
992									return Err(<A::Error as de::Error>::duplicate_field("url"));
993								}
994								r#url_property = Some({
995									struct DeserializeWith(Vec<UrlProperty>);
996									impl<'de> Deserialize<'de> for DeserializeWith {
997										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
998										where
999											D: Deserializer<'de>,
1000										{
1001											Ok(DeserializeWith(serde_with::As::<
1002												serde_with::OneOrMany<serde_with::Same>,
1003											>::deserialize(deserializer)?))
1004										}
1005									}
1006									match map.next_value::<DeserializeWith>() {
1007										Ok(deserialize_with) => deserialize_with.0,
1008										Err(err) => {
1009											return Err(err);
1010										}
1011									}
1012								});
1013							}
1014							Field::Ignore => {
1015								let _ = map.next_value::<de::IgnoredAny>()?;
1016							}
1017						}
1018					}
1019					Ok(ShippingDeliveryTime {
1020						r#business_days: r#business_days_property.unwrap_or_default(),
1021						r#cutoff_time: r#cutoff_time_property.unwrap_or_default(),
1022						r#handling_time: r#handling_time_property.unwrap_or_default(),
1023						r#transit_time: r#transit_time_property.unwrap_or_default(),
1024						r#additional_type: r#additional_type_property.unwrap_or_default(),
1025						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1026						r#description: r#description_property.unwrap_or_default(),
1027						r#disambiguating_description: r#disambiguating_description_property
1028							.unwrap_or_default(),
1029						r#identifier: r#identifier_property.unwrap_or_default(),
1030						r#image: r#image_property.unwrap_or_default(),
1031						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1032						r#name: r#name_property.unwrap_or_default(),
1033						r#potential_action: r#potential_action_property.unwrap_or_default(),
1034						r#same_as: r#same_as_property.unwrap_or_default(),
1035						r#subject_of: r#subject_of_property.unwrap_or_default(),
1036						r#url: r#url_property.unwrap_or_default(),
1037					})
1038				}
1039			}
1040			const FIELDS: &[&str] = &[
1041				"businessDays",
1042				"cutoffTime",
1043				"handlingTime",
1044				"transitTime",
1045				"additionalType",
1046				"alternateName",
1047				"description",
1048				"disambiguatingDescription",
1049				"identifier",
1050				"image",
1051				"mainEntityOfPage",
1052				"name",
1053				"potentialAction",
1054				"sameAs",
1055				"subjectOf",
1056				"url",
1057			];
1058			deserializer.deserialize_struct("ShippingDeliveryTime", FIELDS, ClassVisitor)
1059		}
1060	}
1061}
schema_org_types/schemas/classes/shipping_delivery_time.rs

schema_org_types/schemas/classes/
shipping_delivery_time.rs
