schema_org_types/schemas/classes/
tip_action.rs

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

schema_org_types/schemas/classes/
tip_action.rs
