schema_org_types/schemas/classes/
schedule_action.rs

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

schema_org_types/schemas/classes/
schedule_action.rs
