schema_org_types/schemas/classes/
authorize_action.rs

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

schema_org_types/schemas/classes/
authorize_action.rs
