schema_org_types/schemas/classes/
replace_action.rs

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

schema_org_types/schemas/classes/
replace_action.rs
