schema_org_types/schemas/classes/
subscribe_action.rs

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

schema_org_types/schemas/classes/
subscribe_action.rs
