schema_org_types/schemas/classes/
accept_action.rs

1use super::*;
2/// <https://schema.org/AcceptAction>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct AcceptAction {
6	/// <https://schema.org/actionStatus>
7	pub r#action_status: Vec<ActionStatusProperty>,
8	/// <https://schema.org/agent>
9	pub r#agent: Vec<AgentProperty>,
10	/// <https://schema.org/endTime>
11	pub r#end_time: Vec<EndTimeProperty>,
12	/// <https://schema.org/error>
13	pub r#error: Vec<ErrorProperty>,
14	/// <https://schema.org/instrument>
15	pub r#instrument: Vec<InstrumentProperty>,
16	/// <https://schema.org/location>
17	pub r#location: Vec<LocationProperty>,
18	/// <https://schema.org/object>
19	pub r#object: Vec<ObjectProperty>,
20	/// <https://schema.org/participant>
21	pub r#participant: Vec<ParticipantProperty>,
22	/// <https://schema.org/provider>
23	pub r#provider: Vec<ProviderProperty>,
24	/// <https://schema.org/result>
25	pub r#result: Vec<ResultProperty>,
26	/// <https://schema.org/startTime>
27	pub r#start_time: Vec<StartTimeProperty>,
28	/// <https://schema.org/target>
29	pub r#target: Vec<TargetProperty>,
30	/// <https://schema.org/additionalType>
31	pub r#additional_type: Vec<AdditionalTypeProperty>,
32	/// <https://schema.org/alternateName>
33	pub r#alternate_name: Vec<AlternateNameProperty>,
34	/// <https://schema.org/description>
35	pub r#description: Vec<DescriptionProperty>,
36	/// <https://schema.org/disambiguatingDescription>
37	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
38	/// <https://schema.org/identifier>
39	pub r#identifier: Vec<IdentifierProperty>,
40	/// <https://schema.org/image>
41	pub r#image: Vec<ImageProperty>,
42	/// <https://schema.org/mainEntityOfPage>
43	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
44	/// <https://schema.org/name>
45	pub r#name: Vec<NameProperty>,
46	/// <https://schema.org/potentialAction>
47	pub r#potential_action: Vec<PotentialActionProperty>,
48	/// <https://schema.org/sameAs>
49	pub r#same_as: Vec<SameAsProperty>,
50	/// <https://schema.org/subjectOf>
51	pub r#subject_of: Vec<SubjectOfProperty>,
52	/// <https://schema.org/url>
53	pub r#url: Vec<UrlProperty>,
54}
55/// This trait is for properties from <https://schema.org/AcceptAction>.
56pub trait AcceptActionTrait {}
57impl AcceptActionTrait for AcceptAction {}
58impl ActionTrait for AcceptAction {
59	fn get_action_status(&self) -> &[ActionStatusProperty] {
60		self.r#action_status.as_slice()
61	}
62	fn take_action_status(&mut self) -> Vec<ActionStatusProperty> {
63		std::mem::take(&mut self.r#action_status)
64	}
65	fn get_agent(&self) -> &[AgentProperty] {
66		self.r#agent.as_slice()
67	}
68	fn take_agent(&mut self) -> Vec<AgentProperty> {
69		std::mem::take(&mut self.r#agent)
70	}
71	fn get_end_time(&self) -> &[EndTimeProperty] {
72		self.r#end_time.as_slice()
73	}
74	fn take_end_time(&mut self) -> Vec<EndTimeProperty> {
75		std::mem::take(&mut self.r#end_time)
76	}
77	fn get_error(&self) -> &[ErrorProperty] {
78		self.r#error.as_slice()
79	}
80	fn take_error(&mut self) -> Vec<ErrorProperty> {
81		std::mem::take(&mut self.r#error)
82	}
83	fn get_instrument(&self) -> &[InstrumentProperty] {
84		self.r#instrument.as_slice()
85	}
86	fn take_instrument(&mut self) -> Vec<InstrumentProperty> {
87		std::mem::take(&mut self.r#instrument)
88	}
89	fn get_location(&self) -> &[LocationProperty] {
90		self.r#location.as_slice()
91	}
92	fn take_location(&mut self) -> Vec<LocationProperty> {
93		std::mem::take(&mut self.r#location)
94	}
95	fn get_object(&self) -> &[ObjectProperty] {
96		self.r#object.as_slice()
97	}
98	fn take_object(&mut self) -> Vec<ObjectProperty> {
99		std::mem::take(&mut self.r#object)
100	}
101	fn get_participant(&self) -> &[ParticipantProperty] {
102		self.r#participant.as_slice()
103	}
104	fn take_participant(&mut self) -> Vec<ParticipantProperty> {
105		std::mem::take(&mut self.r#participant)
106	}
107	fn get_provider(&self) -> &[ProviderProperty] {
108		self.r#provider.as_slice()
109	}
110	fn take_provider(&mut self) -> Vec<ProviderProperty> {
111		std::mem::take(&mut self.r#provider)
112	}
113	fn get_result(&self) -> &[ResultProperty] {
114		self.r#result.as_slice()
115	}
116	fn take_result(&mut self) -> Vec<ResultProperty> {
117		std::mem::take(&mut self.r#result)
118	}
119	fn get_start_time(&self) -> &[StartTimeProperty] {
120		self.r#start_time.as_slice()
121	}
122	fn take_start_time(&mut self) -> Vec<StartTimeProperty> {
123		std::mem::take(&mut self.r#start_time)
124	}
125	fn get_target(&self) -> &[TargetProperty] {
126		self.r#target.as_slice()
127	}
128	fn take_target(&mut self) -> Vec<TargetProperty> {
129		std::mem::take(&mut self.r#target)
130	}
131}
132impl AllocateActionTrait for AcceptAction {}
133impl OrganizeActionTrait for AcceptAction {}
134impl ThingTrait for AcceptAction {
135	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
136		self.r#additional_type.as_slice()
137	}
138	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
139		std::mem::take(&mut self.r#additional_type)
140	}
141	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
142		self.r#alternate_name.as_slice()
143	}
144	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
145		std::mem::take(&mut self.r#alternate_name)
146	}
147	fn get_description(&self) -> &[DescriptionProperty] {
148		self.r#description.as_slice()
149	}
150	fn take_description(&mut self) -> Vec<DescriptionProperty> {
151		std::mem::take(&mut self.r#description)
152	}
153	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
154		self.r#disambiguating_description.as_slice()
155	}
156	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
157		std::mem::take(&mut self.r#disambiguating_description)
158	}
159	fn get_identifier(&self) -> &[IdentifierProperty] {
160		self.r#identifier.as_slice()
161	}
162	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
163		std::mem::take(&mut self.r#identifier)
164	}
165	fn get_image(&self) -> &[ImageProperty] {
166		self.r#image.as_slice()
167	}
168	fn take_image(&mut self) -> Vec<ImageProperty> {
169		std::mem::take(&mut self.r#image)
170	}
171	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
172		self.r#main_entity_of_page.as_slice()
173	}
174	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
175		std::mem::take(&mut self.r#main_entity_of_page)
176	}
177	fn get_name(&self) -> &[NameProperty] {
178		self.r#name.as_slice()
179	}
180	fn take_name(&mut self) -> Vec<NameProperty> {
181		std::mem::take(&mut self.r#name)
182	}
183	fn get_potential_action(&self) -> &[PotentialActionProperty] {
184		self.r#potential_action.as_slice()
185	}
186	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
187		std::mem::take(&mut self.r#potential_action)
188	}
189	fn get_same_as(&self) -> &[SameAsProperty] {
190		self.r#same_as.as_slice()
191	}
192	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
193		std::mem::take(&mut self.r#same_as)
194	}
195	fn get_subject_of(&self) -> &[SubjectOfProperty] {
196		self.r#subject_of.as_slice()
197	}
198	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
199		std::mem::take(&mut self.r#subject_of)
200	}
201	fn get_url(&self) -> &[UrlProperty] {
202		self.r#url.as_slice()
203	}
204	fn take_url(&mut self) -> Vec<UrlProperty> {
205		std::mem::take(&mut self.r#url)
206	}
207}
208#[cfg(feature = "serde")]
209mod serde {
210	use std::{fmt, fmt::Formatter};
211
212	use ::serde::{
213		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
214	};
215
216	use super::*;
217	impl Serialize for AcceptAction {
218		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
219		where
220			S: Serializer,
221		{
222			let len: usize = [
223				!Vec::is_empty(&self.r#action_status) as usize,
224				!Vec::is_empty(&self.r#agent) as usize,
225				!Vec::is_empty(&self.r#end_time) as usize,
226				!Vec::is_empty(&self.r#error) as usize,
227				!Vec::is_empty(&self.r#instrument) as usize,
228				!Vec::is_empty(&self.r#location) as usize,
229				!Vec::is_empty(&self.r#object) as usize,
230				!Vec::is_empty(&self.r#participant) as usize,
231				!Vec::is_empty(&self.r#provider) as usize,
232				!Vec::is_empty(&self.r#result) as usize,
233				!Vec::is_empty(&self.r#start_time) as usize,
234				!Vec::is_empty(&self.r#target) as usize,
235				!Vec::is_empty(&self.r#additional_type) as usize,
236				!Vec::is_empty(&self.r#alternate_name) as usize,
237				!Vec::is_empty(&self.r#description) as usize,
238				!Vec::is_empty(&self.r#disambiguating_description) as usize,
239				!Vec::is_empty(&self.r#identifier) as usize,
240				!Vec::is_empty(&self.r#image) as usize,
241				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
242				!Vec::is_empty(&self.r#name) as usize,
243				!Vec::is_empty(&self.r#potential_action) as usize,
244				!Vec::is_empty(&self.r#same_as) as usize,
245				!Vec::is_empty(&self.r#subject_of) as usize,
246				!Vec::is_empty(&self.r#url) as usize,
247			]
248			.iter()
249			.sum();
250			let mut serialize_struct =
251				Serializer::serialize_struct(serializer, "AcceptAction", len)?;
252			if !Vec::is_empty(&self.r#action_status) {
253				serialize_struct.serialize_field("actionStatus", {
254					struct SerializeWith<'a>(&'a Vec<ActionStatusProperty>);
255					impl<'a> Serialize for SerializeWith<'a> {
256						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
257						where
258							S: Serializer,
259						{
260							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
261								self.0, serializer,
262							)
263						}
264					}
265					&SerializeWith(&self.r#action_status)
266				})?;
267			} else {
268				serialize_struct.skip_field("actionStatus")?;
269			}
270			if !Vec::is_empty(&self.r#agent) {
271				serialize_struct.serialize_field("agent", {
272					struct SerializeWith<'a>(&'a Vec<AgentProperty>);
273					impl<'a> Serialize for SerializeWith<'a> {
274						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
275						where
276							S: Serializer,
277						{
278							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
279								self.0, serializer,
280							)
281						}
282					}
283					&SerializeWith(&self.r#agent)
284				})?;
285			} else {
286				serialize_struct.skip_field("agent")?;
287			}
288			if !Vec::is_empty(&self.r#end_time) {
289				serialize_struct.serialize_field("endTime", {
290					struct SerializeWith<'a>(&'a Vec<EndTimeProperty>);
291					impl<'a> Serialize for SerializeWith<'a> {
292						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
293						where
294							S: Serializer,
295						{
296							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
297								self.0, serializer,
298							)
299						}
300					}
301					&SerializeWith(&self.r#end_time)
302				})?;
303			} else {
304				serialize_struct.skip_field("endTime")?;
305			}
306			if !Vec::is_empty(&self.r#error) {
307				serialize_struct.serialize_field("error", {
308					struct SerializeWith<'a>(&'a Vec<ErrorProperty>);
309					impl<'a> Serialize for SerializeWith<'a> {
310						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
311						where
312							S: Serializer,
313						{
314							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
315								self.0, serializer,
316							)
317						}
318					}
319					&SerializeWith(&self.r#error)
320				})?;
321			} else {
322				serialize_struct.skip_field("error")?;
323			}
324			if !Vec::is_empty(&self.r#instrument) {
325				serialize_struct.serialize_field("instrument", {
326					struct SerializeWith<'a>(&'a Vec<InstrumentProperty>);
327					impl<'a> Serialize for SerializeWith<'a> {
328						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
329						where
330							S: Serializer,
331						{
332							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
333								self.0, serializer,
334							)
335						}
336					}
337					&SerializeWith(&self.r#instrument)
338				})?;
339			} else {
340				serialize_struct.skip_field("instrument")?;
341			}
342			if !Vec::is_empty(&self.r#location) {
343				serialize_struct.serialize_field("location", {
344					struct SerializeWith<'a>(&'a Vec<LocationProperty>);
345					impl<'a> Serialize for SerializeWith<'a> {
346						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
347						where
348							S: Serializer,
349						{
350							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
351								self.0, serializer,
352							)
353						}
354					}
355					&SerializeWith(&self.r#location)
356				})?;
357			} else {
358				serialize_struct.skip_field("location")?;
359			}
360			if !Vec::is_empty(&self.r#object) {
361				serialize_struct.serialize_field("object", {
362					struct SerializeWith<'a>(&'a Vec<ObjectProperty>);
363					impl<'a> Serialize for SerializeWith<'a> {
364						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
365						where
366							S: Serializer,
367						{
368							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
369								self.0, serializer,
370							)
371						}
372					}
373					&SerializeWith(&self.r#object)
374				})?;
375			} else {
376				serialize_struct.skip_field("object")?;
377			}
378			if !Vec::is_empty(&self.r#participant) {
379				serialize_struct.serialize_field("participant", {
380					struct SerializeWith<'a>(&'a Vec<ParticipantProperty>);
381					impl<'a> Serialize for SerializeWith<'a> {
382						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
383						where
384							S: Serializer,
385						{
386							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
387								self.0, serializer,
388							)
389						}
390					}
391					&SerializeWith(&self.r#participant)
392				})?;
393			} else {
394				serialize_struct.skip_field("participant")?;
395			}
396			if !Vec::is_empty(&self.r#provider) {
397				serialize_struct.serialize_field("provider", {
398					struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
399					impl<'a> Serialize for SerializeWith<'a> {
400						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
401						where
402							S: Serializer,
403						{
404							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
405								self.0, serializer,
406							)
407						}
408					}
409					&SerializeWith(&self.r#provider)
410				})?;
411			} else {
412				serialize_struct.skip_field("provider")?;
413			}
414			if !Vec::is_empty(&self.r#result) {
415				serialize_struct.serialize_field("result", {
416					struct SerializeWith<'a>(&'a Vec<ResultProperty>);
417					impl<'a> Serialize for SerializeWith<'a> {
418						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
419						where
420							S: Serializer,
421						{
422							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
423								self.0, serializer,
424							)
425						}
426					}
427					&SerializeWith(&self.r#result)
428				})?;
429			} else {
430				serialize_struct.skip_field("result")?;
431			}
432			if !Vec::is_empty(&self.r#start_time) {
433				serialize_struct.serialize_field("startTime", {
434					struct SerializeWith<'a>(&'a Vec<StartTimeProperty>);
435					impl<'a> Serialize for SerializeWith<'a> {
436						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
437						where
438							S: Serializer,
439						{
440							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
441								self.0, serializer,
442							)
443						}
444					}
445					&SerializeWith(&self.r#start_time)
446				})?;
447			} else {
448				serialize_struct.skip_field("startTime")?;
449			}
450			if !Vec::is_empty(&self.r#target) {
451				serialize_struct.serialize_field("target", {
452					struct SerializeWith<'a>(&'a Vec<TargetProperty>);
453					impl<'a> Serialize for SerializeWith<'a> {
454						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
455						where
456							S: Serializer,
457						{
458							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
459								self.0, serializer,
460							)
461						}
462					}
463					&SerializeWith(&self.r#target)
464				})?;
465			} else {
466				serialize_struct.skip_field("target")?;
467			}
468			if !Vec::is_empty(&self.r#additional_type) {
469				serialize_struct.serialize_field("additionalType", {
470					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
471					impl<'a> Serialize for SerializeWith<'a> {
472						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
473						where
474							S: Serializer,
475						{
476							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
477								self.0, serializer,
478							)
479						}
480					}
481					&SerializeWith(&self.r#additional_type)
482				})?;
483			} else {
484				serialize_struct.skip_field("additionalType")?;
485			}
486			if !Vec::is_empty(&self.r#alternate_name) {
487				serialize_struct.serialize_field("alternateName", {
488					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
489					impl<'a> Serialize for SerializeWith<'a> {
490						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
491						where
492							S: Serializer,
493						{
494							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
495								self.0, serializer,
496							)
497						}
498					}
499					&SerializeWith(&self.r#alternate_name)
500				})?;
501			} else {
502				serialize_struct.skip_field("alternateName")?;
503			}
504			if !Vec::is_empty(&self.r#description) {
505				serialize_struct.serialize_field("description", {
506					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
507					impl<'a> Serialize for SerializeWith<'a> {
508						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
509						where
510							S: Serializer,
511						{
512							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
513								self.0, serializer,
514							)
515						}
516					}
517					&SerializeWith(&self.r#description)
518				})?;
519			} else {
520				serialize_struct.skip_field("description")?;
521			}
522			if !Vec::is_empty(&self.r#disambiguating_description) {
523				serialize_struct.serialize_field("disambiguatingDescription", {
524					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
525					impl<'a> Serialize for SerializeWith<'a> {
526						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
527						where
528							S: Serializer,
529						{
530							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
531								self.0, serializer,
532							)
533						}
534					}
535					&SerializeWith(&self.r#disambiguating_description)
536				})?;
537			} else {
538				serialize_struct.skip_field("disambiguatingDescription")?;
539			}
540			if !Vec::is_empty(&self.r#identifier) {
541				serialize_struct.serialize_field("identifier", {
542					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
543					impl<'a> Serialize for SerializeWith<'a> {
544						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
545						where
546							S: Serializer,
547						{
548							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
549								self.0, serializer,
550							)
551						}
552					}
553					&SerializeWith(&self.r#identifier)
554				})?;
555			} else {
556				serialize_struct.skip_field("identifier")?;
557			}
558			if !Vec::is_empty(&self.r#image) {
559				serialize_struct.serialize_field("image", {
560					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
561					impl<'a> Serialize for SerializeWith<'a> {
562						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
563						where
564							S: Serializer,
565						{
566							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
567								self.0, serializer,
568							)
569						}
570					}
571					&SerializeWith(&self.r#image)
572				})?;
573			} else {
574				serialize_struct.skip_field("image")?;
575			}
576			if !Vec::is_empty(&self.r#main_entity_of_page) {
577				serialize_struct.serialize_field("mainEntityOfPage", {
578					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
579					impl<'a> Serialize for SerializeWith<'a> {
580						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
581						where
582							S: Serializer,
583						{
584							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
585								self.0, serializer,
586							)
587						}
588					}
589					&SerializeWith(&self.r#main_entity_of_page)
590				})?;
591			} else {
592				serialize_struct.skip_field("mainEntityOfPage")?;
593			}
594			if !Vec::is_empty(&self.r#name) {
595				serialize_struct.serialize_field("name", {
596					struct SerializeWith<'a>(&'a Vec<NameProperty>);
597					impl<'a> Serialize for SerializeWith<'a> {
598						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
599						where
600							S: Serializer,
601						{
602							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
603								self.0, serializer,
604							)
605						}
606					}
607					&SerializeWith(&self.r#name)
608				})?;
609			} else {
610				serialize_struct.skip_field("name")?;
611			}
612			if !Vec::is_empty(&self.r#potential_action) {
613				serialize_struct.serialize_field("potentialAction", {
614					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
615					impl<'a> Serialize for SerializeWith<'a> {
616						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
617						where
618							S: Serializer,
619						{
620							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
621								self.0, serializer,
622							)
623						}
624					}
625					&SerializeWith(&self.r#potential_action)
626				})?;
627			} else {
628				serialize_struct.skip_field("potentialAction")?;
629			}
630			if !Vec::is_empty(&self.r#same_as) {
631				serialize_struct.serialize_field("sameAs", {
632					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
633					impl<'a> Serialize for SerializeWith<'a> {
634						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
635						where
636							S: Serializer,
637						{
638							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
639								self.0, serializer,
640							)
641						}
642					}
643					&SerializeWith(&self.r#same_as)
644				})?;
645			} else {
646				serialize_struct.skip_field("sameAs")?;
647			}
648			if !Vec::is_empty(&self.r#subject_of) {
649				serialize_struct.serialize_field("subjectOf", {
650					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
651					impl<'a> Serialize for SerializeWith<'a> {
652						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
653						where
654							S: Serializer,
655						{
656							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
657								self.0, serializer,
658							)
659						}
660					}
661					&SerializeWith(&self.r#subject_of)
662				})?;
663			} else {
664				serialize_struct.skip_field("subjectOf")?;
665			}
666			if !Vec::is_empty(&self.r#url) {
667				serialize_struct.serialize_field("url", {
668					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
669					impl<'a> Serialize for SerializeWith<'a> {
670						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
671						where
672							S: Serializer,
673						{
674							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
675								self.0, serializer,
676							)
677						}
678					}
679					&SerializeWith(&self.r#url)
680				})?;
681			} else {
682				serialize_struct.skip_field("url")?;
683			}
684			serialize_struct.end()
685		}
686	}
687	impl<'de> Deserialize<'de> for AcceptAction {
688		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
689		where
690			D: Deserializer<'de>,
691		{
692			enum Field {
693				ActionStatus,
694				Agent,
695				EndTime,
696				Error,
697				Instrument,
698				Location,
699				Object,
700				Participant,
701				Provider,
702				Result,
703				StartTime,
704				Target,
705				AdditionalType,
706				AlternateName,
707				Description,
708				DisambiguatingDescription,
709				Identifier,
710				Image,
711				MainEntityOfPage,
712				Name,
713				PotentialAction,
714				SameAs,
715				SubjectOf,
716				Url,
717				Ignore,
718			}
719			struct FieldVisitor;
720			impl<'de> Visitor<'de> for FieldVisitor {
721				type Value = Field;
722				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
723					formatter.write_str("field identifier")
724				}
725				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
726				where
727					E: de::Error,
728				{
729					match value {
730						"actionStatus" => Ok(Field::ActionStatus),
731						"agent" => Ok(Field::Agent),
732						"endTime" => Ok(Field::EndTime),
733						"error" => Ok(Field::Error),
734						"instrument" => Ok(Field::Instrument),
735						"location" => Ok(Field::Location),
736						"object" => Ok(Field::Object),
737						"participant" => Ok(Field::Participant),
738						"provider" => Ok(Field::Provider),
739						"result" => Ok(Field::Result),
740						"startTime" => Ok(Field::StartTime),
741						"target" => Ok(Field::Target),
742						"additionalType" => Ok(Field::AdditionalType),
743						"alternateName" => Ok(Field::AlternateName),
744						"description" => Ok(Field::Description),
745						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
746						"identifier" => Ok(Field::Identifier),
747						"image" => Ok(Field::Image),
748						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
749						"name" => Ok(Field::Name),
750						"potentialAction" => Ok(Field::PotentialAction),
751						"sameAs" => Ok(Field::SameAs),
752						"subjectOf" => Ok(Field::SubjectOf),
753						"url" => Ok(Field::Url),
754						"id" | "type" => Ok(Field::Ignore),
755						_ => Err(de::Error::unknown_field(value, FIELDS)),
756					}
757				}
758				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
759				where
760					E: de::Error,
761				{
762					match value {
763						b"actionStatus" => Ok(Field::ActionStatus),
764						b"agent" => Ok(Field::Agent),
765						b"endTime" => Ok(Field::EndTime),
766						b"error" => Ok(Field::Error),
767						b"instrument" => Ok(Field::Instrument),
768						b"location" => Ok(Field::Location),
769						b"object" => Ok(Field::Object),
770						b"participant" => Ok(Field::Participant),
771						b"provider" => Ok(Field::Provider),
772						b"result" => Ok(Field::Result),
773						b"startTime" => Ok(Field::StartTime),
774						b"target" => Ok(Field::Target),
775						b"additionalType" => Ok(Field::AdditionalType),
776						b"alternateName" => Ok(Field::AlternateName),
777						b"description" => Ok(Field::Description),
778						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
779						b"identifier" => Ok(Field::Identifier),
780						b"image" => Ok(Field::Image),
781						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
782						b"name" => Ok(Field::Name),
783						b"potentialAction" => Ok(Field::PotentialAction),
784						b"sameAs" => Ok(Field::SameAs),
785						b"subjectOf" => Ok(Field::SubjectOf),
786						b"url" => Ok(Field::Url),
787						b"id" | b"type" => Ok(Field::Ignore),
788						_ => {
789							let value = &String::from_utf8_lossy(value);
790							Err(de::Error::unknown_field(value, FIELDS))
791						}
792					}
793				}
794			}
795			impl<'de> Deserialize<'de> for Field {
796				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
797				where
798					D: Deserializer<'de>,
799				{
800					deserializer.deserialize_identifier(FieldVisitor)
801				}
802			}
803			struct ClassVisitor;
804			impl<'de> Visitor<'de> for ClassVisitor {
805				type Value = AcceptAction;
806				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
807					formatter.write_str("schema.org schema AcceptAction")
808				}
809				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
810				where
811					A: de::MapAccess<'de>,
812				{
813					let mut r#action_status_property = None;
814					let mut r#agent_property = None;
815					let mut r#end_time_property = None;
816					let mut r#error_property = None;
817					let mut r#instrument_property = None;
818					let mut r#location_property = None;
819					let mut r#object_property = None;
820					let mut r#participant_property = None;
821					let mut r#provider_property = None;
822					let mut r#result_property = None;
823					let mut r#start_time_property = None;
824					let mut r#target_property = None;
825					let mut r#additional_type_property = None;
826					let mut r#alternate_name_property = None;
827					let mut r#description_property = None;
828					let mut r#disambiguating_description_property = None;
829					let mut r#identifier_property = None;
830					let mut r#image_property = None;
831					let mut r#main_entity_of_page_property = None;
832					let mut r#name_property = None;
833					let mut r#potential_action_property = None;
834					let mut r#same_as_property = None;
835					let mut r#subject_of_property = None;
836					let mut r#url_property = None;
837					while let Some(key) = map.next_key::<Field>()? {
838						match key {
839							Field::ActionStatus => {
840								if r#action_status_property.is_some() {
841									return Err(<A::Error as de::Error>::duplicate_field(
842										"actionStatus",
843									));
844								}
845								r#action_status_property = Some({
846									struct DeserializeWith(Vec<ActionStatusProperty>);
847									impl<'de> Deserialize<'de> for DeserializeWith {
848										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
849										where
850											D: Deserializer<'de>,
851										{
852											Ok(DeserializeWith(serde_with::As::<
853												serde_with::OneOrMany<serde_with::Same>,
854											>::deserialize(deserializer)?))
855										}
856									}
857									match map.next_value::<DeserializeWith>() {
858										Ok(deserialize_with) => deserialize_with.0,
859										Err(err) => {
860											return Err(err);
861										}
862									}
863								});
864							}
865							Field::Agent => {
866								if r#agent_property.is_some() {
867									return Err(<A::Error as de::Error>::duplicate_field("agent"));
868								}
869								r#agent_property = Some({
870									struct DeserializeWith(Vec<AgentProperty>);
871									impl<'de> Deserialize<'de> for DeserializeWith {
872										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
873										where
874											D: Deserializer<'de>,
875										{
876											Ok(DeserializeWith(serde_with::As::<
877												serde_with::OneOrMany<serde_with::Same>,
878											>::deserialize(deserializer)?))
879										}
880									}
881									match map.next_value::<DeserializeWith>() {
882										Ok(deserialize_with) => deserialize_with.0,
883										Err(err) => {
884											return Err(err);
885										}
886									}
887								});
888							}
889							Field::EndTime => {
890								if r#end_time_property.is_some() {
891									return Err(<A::Error as de::Error>::duplicate_field(
892										"endTime",
893									));
894								}
895								r#end_time_property = Some({
896									struct DeserializeWith(Vec<EndTimeProperty>);
897									impl<'de> Deserialize<'de> for DeserializeWith {
898										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
899										where
900											D: Deserializer<'de>,
901										{
902											Ok(DeserializeWith(serde_with::As::<
903												serde_with::OneOrMany<serde_with::Same>,
904											>::deserialize(deserializer)?))
905										}
906									}
907									match map.next_value::<DeserializeWith>() {
908										Ok(deserialize_with) => deserialize_with.0,
909										Err(err) => {
910											return Err(err);
911										}
912									}
913								});
914							}
915							Field::Error => {
916								if r#error_property.is_some() {
917									return Err(<A::Error as de::Error>::duplicate_field("error"));
918								}
919								r#error_property = Some({
920									struct DeserializeWith(Vec<ErrorProperty>);
921									impl<'de> Deserialize<'de> for DeserializeWith {
922										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
923										where
924											D: Deserializer<'de>,
925										{
926											Ok(DeserializeWith(serde_with::As::<
927												serde_with::OneOrMany<serde_with::Same>,
928											>::deserialize(deserializer)?))
929										}
930									}
931									match map.next_value::<DeserializeWith>() {
932										Ok(deserialize_with) => deserialize_with.0,
933										Err(err) => {
934											return Err(err);
935										}
936									}
937								});
938							}
939							Field::Instrument => {
940								if r#instrument_property.is_some() {
941									return Err(<A::Error as de::Error>::duplicate_field(
942										"instrument",
943									));
944								}
945								r#instrument_property = Some({
946									struct DeserializeWith(Vec<InstrumentProperty>);
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::Location => {
966								if r#location_property.is_some() {
967									return Err(<A::Error as de::Error>::duplicate_field(
968										"location",
969									));
970								}
971								r#location_property = Some({
972									struct DeserializeWith(Vec<LocationProperty>);
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::Object => {
992								if r#object_property.is_some() {
993									return Err(<A::Error as de::Error>::duplicate_field("object"));
994								}
995								r#object_property = Some({
996									struct DeserializeWith(Vec<ObjectProperty>);
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::Participant => {
1016								if r#participant_property.is_some() {
1017									return Err(<A::Error as de::Error>::duplicate_field(
1018										"participant",
1019									));
1020								}
1021								r#participant_property = Some({
1022									struct DeserializeWith(Vec<ParticipantProperty>);
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::Provider => {
1042								if r#provider_property.is_some() {
1043									return Err(<A::Error as de::Error>::duplicate_field(
1044										"provider",
1045									));
1046								}
1047								r#provider_property = Some({
1048									struct DeserializeWith(Vec<ProviderProperty>);
1049									impl<'de> Deserialize<'de> for DeserializeWith {
1050										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1051										where
1052											D: Deserializer<'de>,
1053										{
1054											Ok(DeserializeWith(serde_with::As::<
1055												serde_with::OneOrMany<serde_with::Same>,
1056											>::deserialize(deserializer)?))
1057										}
1058									}
1059									match map.next_value::<DeserializeWith>() {
1060										Ok(deserialize_with) => deserialize_with.0,
1061										Err(err) => {
1062											return Err(err);
1063										}
1064									}
1065								});
1066							}
1067							Field::Result => {
1068								if r#result_property.is_some() {
1069									return Err(<A::Error as de::Error>::duplicate_field("result"));
1070								}
1071								r#result_property = Some({
1072									struct DeserializeWith(Vec<ResultProperty>);
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::StartTime => {
1092								if r#start_time_property.is_some() {
1093									return Err(<A::Error as de::Error>::duplicate_field(
1094										"startTime",
1095									));
1096								}
1097								r#start_time_property = Some({
1098									struct DeserializeWith(Vec<StartTimeProperty>);
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::Target => {
1118								if r#target_property.is_some() {
1119									return Err(<A::Error as de::Error>::duplicate_field("target"));
1120								}
1121								r#target_property = Some({
1122									struct DeserializeWith(Vec<TargetProperty>);
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::AdditionalType => {
1142								if r#additional_type_property.is_some() {
1143									return Err(<A::Error as de::Error>::duplicate_field(
1144										"additionalType",
1145									));
1146								}
1147								r#additional_type_property = Some({
1148									struct DeserializeWith(Vec<AdditionalTypeProperty>);
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::AlternateName => {
1168								if r#alternate_name_property.is_some() {
1169									return Err(<A::Error as de::Error>::duplicate_field(
1170										"alternateName",
1171									));
1172								}
1173								r#alternate_name_property = Some({
1174									struct DeserializeWith(Vec<AlternateNameProperty>);
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::Description => {
1194								if r#description_property.is_some() {
1195									return Err(<A::Error as de::Error>::duplicate_field(
1196										"description",
1197									));
1198								}
1199								r#description_property = Some({
1200									struct DeserializeWith(Vec<DescriptionProperty>);
1201									impl<'de> Deserialize<'de> for DeserializeWith {
1202										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1203										where
1204											D: Deserializer<'de>,
1205										{
1206											Ok(DeserializeWith(serde_with::As::<
1207												serde_with::OneOrMany<serde_with::Same>,
1208											>::deserialize(deserializer)?))
1209										}
1210									}
1211									match map.next_value::<DeserializeWith>() {
1212										Ok(deserialize_with) => deserialize_with.0,
1213										Err(err) => {
1214											return Err(err);
1215										}
1216									}
1217								});
1218							}
1219							Field::DisambiguatingDescription => {
1220								if r#disambiguating_description_property.is_some() {
1221									return Err(<A::Error as de::Error>::duplicate_field(
1222										"disambiguatingDescription",
1223									));
1224								}
1225								r#disambiguating_description_property = Some({
1226									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1227									impl<'de> Deserialize<'de> for DeserializeWith {
1228										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1229										where
1230											D: Deserializer<'de>,
1231										{
1232											Ok(DeserializeWith(serde_with::As::<
1233												serde_with::OneOrMany<serde_with::Same>,
1234											>::deserialize(deserializer)?))
1235										}
1236									}
1237									match map.next_value::<DeserializeWith>() {
1238										Ok(deserialize_with) => deserialize_with.0,
1239										Err(err) => {
1240											return Err(err);
1241										}
1242									}
1243								});
1244							}
1245							Field::Identifier => {
1246								if r#identifier_property.is_some() {
1247									return Err(<A::Error as de::Error>::duplicate_field(
1248										"identifier",
1249									));
1250								}
1251								r#identifier_property = Some({
1252									struct DeserializeWith(Vec<IdentifierProperty>);
1253									impl<'de> Deserialize<'de> for DeserializeWith {
1254										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1255										where
1256											D: Deserializer<'de>,
1257										{
1258											Ok(DeserializeWith(serde_with::As::<
1259												serde_with::OneOrMany<serde_with::Same>,
1260											>::deserialize(deserializer)?))
1261										}
1262									}
1263									match map.next_value::<DeserializeWith>() {
1264										Ok(deserialize_with) => deserialize_with.0,
1265										Err(err) => {
1266											return Err(err);
1267										}
1268									}
1269								});
1270							}
1271							Field::Image => {
1272								if r#image_property.is_some() {
1273									return Err(<A::Error as de::Error>::duplicate_field("image"));
1274								}
1275								r#image_property = Some({
1276									struct DeserializeWith(Vec<ImageProperty>);
1277									impl<'de> Deserialize<'de> for DeserializeWith {
1278										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1279										where
1280											D: Deserializer<'de>,
1281										{
1282											Ok(DeserializeWith(serde_with::As::<
1283												serde_with::OneOrMany<serde_with::Same>,
1284											>::deserialize(deserializer)?))
1285										}
1286									}
1287									match map.next_value::<DeserializeWith>() {
1288										Ok(deserialize_with) => deserialize_with.0,
1289										Err(err) => {
1290											return Err(err);
1291										}
1292									}
1293								});
1294							}
1295							Field::MainEntityOfPage => {
1296								if r#main_entity_of_page_property.is_some() {
1297									return Err(<A::Error as de::Error>::duplicate_field(
1298										"mainEntityOfPage",
1299									));
1300								}
1301								r#main_entity_of_page_property = Some({
1302									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1303									impl<'de> Deserialize<'de> for DeserializeWith {
1304										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1305										where
1306											D: Deserializer<'de>,
1307										{
1308											Ok(DeserializeWith(serde_with::As::<
1309												serde_with::OneOrMany<serde_with::Same>,
1310											>::deserialize(deserializer)?))
1311										}
1312									}
1313									match map.next_value::<DeserializeWith>() {
1314										Ok(deserialize_with) => deserialize_with.0,
1315										Err(err) => {
1316											return Err(err);
1317										}
1318									}
1319								});
1320							}
1321							Field::Name => {
1322								if r#name_property.is_some() {
1323									return Err(<A::Error as de::Error>::duplicate_field("name"));
1324								}
1325								r#name_property = Some({
1326									struct DeserializeWith(Vec<NameProperty>);
1327									impl<'de> Deserialize<'de> for DeserializeWith {
1328										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1329										where
1330											D: Deserializer<'de>,
1331										{
1332											Ok(DeserializeWith(serde_with::As::<
1333												serde_with::OneOrMany<serde_with::Same>,
1334											>::deserialize(deserializer)?))
1335										}
1336									}
1337									match map.next_value::<DeserializeWith>() {
1338										Ok(deserialize_with) => deserialize_with.0,
1339										Err(err) => {
1340											return Err(err);
1341										}
1342									}
1343								});
1344							}
1345							Field::PotentialAction => {
1346								if r#potential_action_property.is_some() {
1347									return Err(<A::Error as de::Error>::duplicate_field(
1348										"potentialAction",
1349									));
1350								}
1351								r#potential_action_property = Some({
1352									struct DeserializeWith(Vec<PotentialActionProperty>);
1353									impl<'de> Deserialize<'de> for DeserializeWith {
1354										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1355										where
1356											D: Deserializer<'de>,
1357										{
1358											Ok(DeserializeWith(serde_with::As::<
1359												serde_with::OneOrMany<serde_with::Same>,
1360											>::deserialize(deserializer)?))
1361										}
1362									}
1363									match map.next_value::<DeserializeWith>() {
1364										Ok(deserialize_with) => deserialize_with.0,
1365										Err(err) => {
1366											return Err(err);
1367										}
1368									}
1369								});
1370							}
1371							Field::SameAs => {
1372								if r#same_as_property.is_some() {
1373									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1374								}
1375								r#same_as_property = Some({
1376									struct DeserializeWith(Vec<SameAsProperty>);
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::SubjectOf => {
1396								if r#subject_of_property.is_some() {
1397									return Err(<A::Error as de::Error>::duplicate_field(
1398										"subjectOf",
1399									));
1400								}
1401								r#subject_of_property = Some({
1402									struct DeserializeWith(Vec<SubjectOfProperty>);
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::Url => {
1422								if r#url_property.is_some() {
1423									return Err(<A::Error as de::Error>::duplicate_field("url"));
1424								}
1425								r#url_property = Some({
1426									struct DeserializeWith(Vec<UrlProperty>);
1427									impl<'de> Deserialize<'de> for DeserializeWith {
1428										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1429										where
1430											D: Deserializer<'de>,
1431										{
1432											Ok(DeserializeWith(serde_with::As::<
1433												serde_with::OneOrMany<serde_with::Same>,
1434											>::deserialize(deserializer)?))
1435										}
1436									}
1437									match map.next_value::<DeserializeWith>() {
1438										Ok(deserialize_with) => deserialize_with.0,
1439										Err(err) => {
1440											return Err(err);
1441										}
1442									}
1443								});
1444							}
1445							Field::Ignore => {
1446								let _ = map.next_value::<de::IgnoredAny>()?;
1447							}
1448						}
1449					}
1450					Ok(AcceptAction {
1451						r#action_status: r#action_status_property.unwrap_or_default(),
1452						r#agent: r#agent_property.unwrap_or_default(),
1453						r#end_time: r#end_time_property.unwrap_or_default(),
1454						r#error: r#error_property.unwrap_or_default(),
1455						r#instrument: r#instrument_property.unwrap_or_default(),
1456						r#location: r#location_property.unwrap_or_default(),
1457						r#object: r#object_property.unwrap_or_default(),
1458						r#participant: r#participant_property.unwrap_or_default(),
1459						r#provider: r#provider_property.unwrap_or_default(),
1460						r#result: r#result_property.unwrap_or_default(),
1461						r#start_time: r#start_time_property.unwrap_or_default(),
1462						r#target: r#target_property.unwrap_or_default(),
1463						r#additional_type: r#additional_type_property.unwrap_or_default(),
1464						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1465						r#description: r#description_property.unwrap_or_default(),
1466						r#disambiguating_description: r#disambiguating_description_property
1467							.unwrap_or_default(),
1468						r#identifier: r#identifier_property.unwrap_or_default(),
1469						r#image: r#image_property.unwrap_or_default(),
1470						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1471						r#name: r#name_property.unwrap_or_default(),
1472						r#potential_action: r#potential_action_property.unwrap_or_default(),
1473						r#same_as: r#same_as_property.unwrap_or_default(),
1474						r#subject_of: r#subject_of_property.unwrap_or_default(),
1475						r#url: r#url_property.unwrap_or_default(),
1476					})
1477				}
1478			}
1479			const FIELDS: &[&str] = &[
1480				"actionStatus",
1481				"agent",
1482				"endTime",
1483				"error",
1484				"instrument",
1485				"location",
1486				"object",
1487				"participant",
1488				"provider",
1489				"result",
1490				"startTime",
1491				"target",
1492				"additionalType",
1493				"alternateName",
1494				"description",
1495				"disambiguatingDescription",
1496				"identifier",
1497				"image",
1498				"mainEntityOfPage",
1499				"name",
1500				"potentialAction",
1501				"sameAs",
1502				"subjectOf",
1503				"url",
1504			];
1505			deserializer.deserialize_struct("AcceptAction", FIELDS, ClassVisitor)
1506		}
1507	}
1508}