schema_org_types/schemas/classes/
quote_action.rs

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

schema_org_types/schemas/classes/
quote_action.rs
