schema_org_types/schemas/classes/
eat_action.rs

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

schema_org_types/schemas/classes/
eat_action.rs
