schema_org_types/schemas/classes/
tie_action.rs

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

schema_org_types/schemas/classes/
tie_action.rs
