schema_org_types/schemas/classes/
vote_action.rs

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

schema_org_types/schemas/classes/
vote_action.rs
