schema_org_types/schemas/classes/
drink_action.rs

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

schema_org_types/schemas/classes/
drink_action.rs
