schema_org_types/schemas/classes/
occupation.rs

1use super::*;
2/// <https://schema.org/Occupation>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Occupation {
6	/// <https://schema.org/educationRequirements>
7	pub r#education_requirements: Vec<EducationRequirementsProperty>,
8	/// <https://schema.org/estimatedSalary>
9	pub r#estimated_salary: Vec<EstimatedSalaryProperty>,
10	/// <https://schema.org/experienceRequirements>
11	pub r#experience_requirements: Vec<ExperienceRequirementsProperty>,
12	/// <https://schema.org/occupationLocation>
13	pub r#occupation_location: Vec<OccupationLocationProperty>,
14	/// <https://schema.org/occupationalCategory>
15	pub r#occupational_category: Vec<OccupationalCategoryProperty>,
16	/// <https://schema.org/qualifications>
17	pub r#qualifications: Vec<QualificationsProperty>,
18	/// <https://schema.org/responsibilities>
19	pub r#responsibilities: Vec<ResponsibilitiesProperty>,
20	/// <https://schema.org/skills>
21	pub r#skills: Vec<SkillsProperty>,
22	/// <https://schema.org/additionalType>
23	pub r#additional_type: Vec<AdditionalTypeProperty>,
24	/// <https://schema.org/alternateName>
25	pub r#alternate_name: Vec<AlternateNameProperty>,
26	/// <https://schema.org/description>
27	pub r#description: Vec<DescriptionProperty>,
28	/// <https://schema.org/disambiguatingDescription>
29	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
30	/// <https://schema.org/identifier>
31	pub r#identifier: Vec<IdentifierProperty>,
32	/// <https://schema.org/image>
33	pub r#image: Vec<ImageProperty>,
34	/// <https://schema.org/mainEntityOfPage>
35	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
36	/// <https://schema.org/name>
37	pub r#name: Vec<NameProperty>,
38	/// <https://schema.org/potentialAction>
39	pub r#potential_action: Vec<PotentialActionProperty>,
40	/// <https://schema.org/sameAs>
41	pub r#same_as: Vec<SameAsProperty>,
42	/// <https://schema.org/subjectOf>
43	pub r#subject_of: Vec<SubjectOfProperty>,
44	/// <https://schema.org/url>
45	pub r#url: Vec<UrlProperty>,
46}
47/// This trait is for properties from <https://schema.org/Occupation>.
48pub trait OccupationTrait {
49	/// Get <https://schema.org/educationRequirements> from [`Self`] as borrowed slice.
50	fn get_education_requirements(&self) -> &[EducationRequirementsProperty];
51	/// Take <https://schema.org/educationRequirements> from [`Self`] as owned vector.
52	fn take_education_requirements(&mut self) -> Vec<EducationRequirementsProperty>;
53	/// Get <https://schema.org/estimatedSalary> from [`Self`] as borrowed slice.
54	fn get_estimated_salary(&self) -> &[EstimatedSalaryProperty];
55	/// Take <https://schema.org/estimatedSalary> from [`Self`] as owned vector.
56	fn take_estimated_salary(&mut self) -> Vec<EstimatedSalaryProperty>;
57	/// Get <https://schema.org/experienceRequirements> from [`Self`] as borrowed slice.
58	fn get_experience_requirements(&self) -> &[ExperienceRequirementsProperty];
59	/// Take <https://schema.org/experienceRequirements> from [`Self`] as owned vector.
60	fn take_experience_requirements(&mut self) -> Vec<ExperienceRequirementsProperty>;
61	/// Get <https://schema.org/occupationLocation> from [`Self`] as borrowed slice.
62	fn get_occupation_location(&self) -> &[OccupationLocationProperty];
63	/// Take <https://schema.org/occupationLocation> from [`Self`] as owned vector.
64	fn take_occupation_location(&mut self) -> Vec<OccupationLocationProperty>;
65	/// Get <https://schema.org/occupationalCategory> from [`Self`] as borrowed slice.
66	fn get_occupational_category(&self) -> &[OccupationalCategoryProperty];
67	/// Take <https://schema.org/occupationalCategory> from [`Self`] as owned vector.
68	fn take_occupational_category(&mut self) -> Vec<OccupationalCategoryProperty>;
69	/// Get <https://schema.org/qualifications> from [`Self`] as borrowed slice.
70	fn get_qualifications(&self) -> &[QualificationsProperty];
71	/// Take <https://schema.org/qualifications> from [`Self`] as owned vector.
72	fn take_qualifications(&mut self) -> Vec<QualificationsProperty>;
73	/// Get <https://schema.org/responsibilities> from [`Self`] as borrowed slice.
74	fn get_responsibilities(&self) -> &[ResponsibilitiesProperty];
75	/// Take <https://schema.org/responsibilities> from [`Self`] as owned vector.
76	fn take_responsibilities(&mut self) -> Vec<ResponsibilitiesProperty>;
77	/// Get <https://schema.org/skills> from [`Self`] as borrowed slice.
78	fn get_skills(&self) -> &[SkillsProperty];
79	/// Take <https://schema.org/skills> from [`Self`] as owned vector.
80	fn take_skills(&mut self) -> Vec<SkillsProperty>;
81}
82impl OccupationTrait for Occupation {
83	fn get_education_requirements(&self) -> &[EducationRequirementsProperty] {
84		self.r#education_requirements.as_slice()
85	}
86	fn take_education_requirements(&mut self) -> Vec<EducationRequirementsProperty> {
87		std::mem::take(&mut self.r#education_requirements)
88	}
89	fn get_estimated_salary(&self) -> &[EstimatedSalaryProperty] {
90		self.r#estimated_salary.as_slice()
91	}
92	fn take_estimated_salary(&mut self) -> Vec<EstimatedSalaryProperty> {
93		std::mem::take(&mut self.r#estimated_salary)
94	}
95	fn get_experience_requirements(&self) -> &[ExperienceRequirementsProperty] {
96		self.r#experience_requirements.as_slice()
97	}
98	fn take_experience_requirements(&mut self) -> Vec<ExperienceRequirementsProperty> {
99		std::mem::take(&mut self.r#experience_requirements)
100	}
101	fn get_occupation_location(&self) -> &[OccupationLocationProperty] {
102		self.r#occupation_location.as_slice()
103	}
104	fn take_occupation_location(&mut self) -> Vec<OccupationLocationProperty> {
105		std::mem::take(&mut self.r#occupation_location)
106	}
107	fn get_occupational_category(&self) -> &[OccupationalCategoryProperty] {
108		self.r#occupational_category.as_slice()
109	}
110	fn take_occupational_category(&mut self) -> Vec<OccupationalCategoryProperty> {
111		std::mem::take(&mut self.r#occupational_category)
112	}
113	fn get_qualifications(&self) -> &[QualificationsProperty] {
114		self.r#qualifications.as_slice()
115	}
116	fn take_qualifications(&mut self) -> Vec<QualificationsProperty> {
117		std::mem::take(&mut self.r#qualifications)
118	}
119	fn get_responsibilities(&self) -> &[ResponsibilitiesProperty] {
120		self.r#responsibilities.as_slice()
121	}
122	fn take_responsibilities(&mut self) -> Vec<ResponsibilitiesProperty> {
123		std::mem::take(&mut self.r#responsibilities)
124	}
125	fn get_skills(&self) -> &[SkillsProperty] {
126		self.r#skills.as_slice()
127	}
128	fn take_skills(&mut self) -> Vec<SkillsProperty> {
129		std::mem::take(&mut self.r#skills)
130	}
131}
132impl ThingTrait for Occupation {
133	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
134		self.r#additional_type.as_slice()
135	}
136	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
137		std::mem::take(&mut self.r#additional_type)
138	}
139	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
140		self.r#alternate_name.as_slice()
141	}
142	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
143		std::mem::take(&mut self.r#alternate_name)
144	}
145	fn get_description(&self) -> &[DescriptionProperty] {
146		self.r#description.as_slice()
147	}
148	fn take_description(&mut self) -> Vec<DescriptionProperty> {
149		std::mem::take(&mut self.r#description)
150	}
151	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
152		self.r#disambiguating_description.as_slice()
153	}
154	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
155		std::mem::take(&mut self.r#disambiguating_description)
156	}
157	fn get_identifier(&self) -> &[IdentifierProperty] {
158		self.r#identifier.as_slice()
159	}
160	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
161		std::mem::take(&mut self.r#identifier)
162	}
163	fn get_image(&self) -> &[ImageProperty] {
164		self.r#image.as_slice()
165	}
166	fn take_image(&mut self) -> Vec<ImageProperty> {
167		std::mem::take(&mut self.r#image)
168	}
169	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
170		self.r#main_entity_of_page.as_slice()
171	}
172	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
173		std::mem::take(&mut self.r#main_entity_of_page)
174	}
175	fn get_name(&self) -> &[NameProperty] {
176		self.r#name.as_slice()
177	}
178	fn take_name(&mut self) -> Vec<NameProperty> {
179		std::mem::take(&mut self.r#name)
180	}
181	fn get_potential_action(&self) -> &[PotentialActionProperty] {
182		self.r#potential_action.as_slice()
183	}
184	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
185		std::mem::take(&mut self.r#potential_action)
186	}
187	fn get_same_as(&self) -> &[SameAsProperty] {
188		self.r#same_as.as_slice()
189	}
190	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
191		std::mem::take(&mut self.r#same_as)
192	}
193	fn get_subject_of(&self) -> &[SubjectOfProperty] {
194		self.r#subject_of.as_slice()
195	}
196	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
197		std::mem::take(&mut self.r#subject_of)
198	}
199	fn get_url(&self) -> &[UrlProperty] {
200		self.r#url.as_slice()
201	}
202	fn take_url(&mut self) -> Vec<UrlProperty> {
203		std::mem::take(&mut self.r#url)
204	}
205}
206#[cfg(feature = "serde")]
207mod serde {
208	use std::{fmt, fmt::Formatter};
209
210	use ::serde::{
211		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
212	};
213
214	use super::*;
215	impl Serialize for Occupation {
216		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
217		where
218			S: Serializer,
219		{
220			let len: usize = [
221				!Vec::is_empty(&self.r#education_requirements) as usize,
222				!Vec::is_empty(&self.r#estimated_salary) as usize,
223				!Vec::is_empty(&self.r#experience_requirements) as usize,
224				!Vec::is_empty(&self.r#occupation_location) as usize,
225				!Vec::is_empty(&self.r#occupational_category) as usize,
226				!Vec::is_empty(&self.r#qualifications) as usize,
227				!Vec::is_empty(&self.r#responsibilities) as usize,
228				!Vec::is_empty(&self.r#skills) as usize,
229				!Vec::is_empty(&self.r#additional_type) as usize,
230				!Vec::is_empty(&self.r#alternate_name) as usize,
231				!Vec::is_empty(&self.r#description) as usize,
232				!Vec::is_empty(&self.r#disambiguating_description) as usize,
233				!Vec::is_empty(&self.r#identifier) as usize,
234				!Vec::is_empty(&self.r#image) as usize,
235				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
236				!Vec::is_empty(&self.r#name) as usize,
237				!Vec::is_empty(&self.r#potential_action) as usize,
238				!Vec::is_empty(&self.r#same_as) as usize,
239				!Vec::is_empty(&self.r#subject_of) as usize,
240				!Vec::is_empty(&self.r#url) as usize,
241			]
242			.iter()
243			.sum();
244			let mut serialize_struct = Serializer::serialize_struct(serializer, "Occupation", len)?;
245			if !Vec::is_empty(&self.r#education_requirements) {
246				serialize_struct.serialize_field("educationRequirements", {
247					struct SerializeWith<'a>(&'a Vec<EducationRequirementsProperty>);
248					impl<'a> Serialize for SerializeWith<'a> {
249						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
250						where
251							S: Serializer,
252						{
253							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
254								self.0, serializer,
255							)
256						}
257					}
258					&SerializeWith(&self.r#education_requirements)
259				})?;
260			} else {
261				serialize_struct.skip_field("educationRequirements")?;
262			}
263			if !Vec::is_empty(&self.r#estimated_salary) {
264				serialize_struct.serialize_field("estimatedSalary", {
265					struct SerializeWith<'a>(&'a Vec<EstimatedSalaryProperty>);
266					impl<'a> Serialize for SerializeWith<'a> {
267						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
268						where
269							S: Serializer,
270						{
271							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
272								self.0, serializer,
273							)
274						}
275					}
276					&SerializeWith(&self.r#estimated_salary)
277				})?;
278			} else {
279				serialize_struct.skip_field("estimatedSalary")?;
280			}
281			if !Vec::is_empty(&self.r#experience_requirements) {
282				serialize_struct.serialize_field("experienceRequirements", {
283					struct SerializeWith<'a>(&'a Vec<ExperienceRequirementsProperty>);
284					impl<'a> Serialize for SerializeWith<'a> {
285						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
286						where
287							S: Serializer,
288						{
289							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
290								self.0, serializer,
291							)
292						}
293					}
294					&SerializeWith(&self.r#experience_requirements)
295				})?;
296			} else {
297				serialize_struct.skip_field("experienceRequirements")?;
298			}
299			if !Vec::is_empty(&self.r#occupation_location) {
300				serialize_struct.serialize_field("occupationLocation", {
301					struct SerializeWith<'a>(&'a Vec<OccupationLocationProperty>);
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#occupation_location)
313				})?;
314			} else {
315				serialize_struct.skip_field("occupationLocation")?;
316			}
317			if !Vec::is_empty(&self.r#occupational_category) {
318				serialize_struct.serialize_field("occupationalCategory", {
319					struct SerializeWith<'a>(&'a Vec<OccupationalCategoryProperty>);
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#occupational_category)
331				})?;
332			} else {
333				serialize_struct.skip_field("occupationalCategory")?;
334			}
335			if !Vec::is_empty(&self.r#qualifications) {
336				serialize_struct.serialize_field("qualifications", {
337					struct SerializeWith<'a>(&'a Vec<QualificationsProperty>);
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#qualifications)
349				})?;
350			} else {
351				serialize_struct.skip_field("qualifications")?;
352			}
353			if !Vec::is_empty(&self.r#responsibilities) {
354				serialize_struct.serialize_field("responsibilities", {
355					struct SerializeWith<'a>(&'a Vec<ResponsibilitiesProperty>);
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#responsibilities)
367				})?;
368			} else {
369				serialize_struct.skip_field("responsibilities")?;
370			}
371			if !Vec::is_empty(&self.r#skills) {
372				serialize_struct.serialize_field("skills", {
373					struct SerializeWith<'a>(&'a Vec<SkillsProperty>);
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#skills)
385				})?;
386			} else {
387				serialize_struct.skip_field("skills")?;
388			}
389			if !Vec::is_empty(&self.r#additional_type) {
390				serialize_struct.serialize_field("additionalType", {
391					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
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#additional_type)
403				})?;
404			} else {
405				serialize_struct.skip_field("additionalType")?;
406			}
407			if !Vec::is_empty(&self.r#alternate_name) {
408				serialize_struct.serialize_field("alternateName", {
409					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
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#alternate_name)
421				})?;
422			} else {
423				serialize_struct.skip_field("alternateName")?;
424			}
425			if !Vec::is_empty(&self.r#description) {
426				serialize_struct.serialize_field("description", {
427					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
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#description)
439				})?;
440			} else {
441				serialize_struct.skip_field("description")?;
442			}
443			if !Vec::is_empty(&self.r#disambiguating_description) {
444				serialize_struct.serialize_field("disambiguatingDescription", {
445					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
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#disambiguating_description)
457				})?;
458			} else {
459				serialize_struct.skip_field("disambiguatingDescription")?;
460			}
461			if !Vec::is_empty(&self.r#identifier) {
462				serialize_struct.serialize_field("identifier", {
463					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
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#identifier)
475				})?;
476			} else {
477				serialize_struct.skip_field("identifier")?;
478			}
479			if !Vec::is_empty(&self.r#image) {
480				serialize_struct.serialize_field("image", {
481					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
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#image)
493				})?;
494			} else {
495				serialize_struct.skip_field("image")?;
496			}
497			if !Vec::is_empty(&self.r#main_entity_of_page) {
498				serialize_struct.serialize_field("mainEntityOfPage", {
499					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
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#main_entity_of_page)
511				})?;
512			} else {
513				serialize_struct.skip_field("mainEntityOfPage")?;
514			}
515			if !Vec::is_empty(&self.r#name) {
516				serialize_struct.serialize_field("name", {
517					struct SerializeWith<'a>(&'a Vec<NameProperty>);
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#name)
529				})?;
530			} else {
531				serialize_struct.skip_field("name")?;
532			}
533			if !Vec::is_empty(&self.r#potential_action) {
534				serialize_struct.serialize_field("potentialAction", {
535					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
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#potential_action)
547				})?;
548			} else {
549				serialize_struct.skip_field("potentialAction")?;
550			}
551			if !Vec::is_empty(&self.r#same_as) {
552				serialize_struct.serialize_field("sameAs", {
553					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
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#same_as)
565				})?;
566			} else {
567				serialize_struct.skip_field("sameAs")?;
568			}
569			if !Vec::is_empty(&self.r#subject_of) {
570				serialize_struct.serialize_field("subjectOf", {
571					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
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#subject_of)
583				})?;
584			} else {
585				serialize_struct.skip_field("subjectOf")?;
586			}
587			if !Vec::is_empty(&self.r#url) {
588				serialize_struct.serialize_field("url", {
589					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
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#url)
601				})?;
602			} else {
603				serialize_struct.skip_field("url")?;
604			}
605			serialize_struct.end()
606		}
607	}
608	impl<'de> Deserialize<'de> for Occupation {
609		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
610		where
611			D: Deserializer<'de>,
612		{
613			enum Field {
614				EducationRequirements,
615				EstimatedSalary,
616				ExperienceRequirements,
617				OccupationLocation,
618				OccupationalCategory,
619				Qualifications,
620				Responsibilities,
621				Skills,
622				AdditionalType,
623				AlternateName,
624				Description,
625				DisambiguatingDescription,
626				Identifier,
627				Image,
628				MainEntityOfPage,
629				Name,
630				PotentialAction,
631				SameAs,
632				SubjectOf,
633				Url,
634				Ignore,
635			}
636			struct FieldVisitor;
637			impl<'de> Visitor<'de> for FieldVisitor {
638				type Value = Field;
639				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
640					formatter.write_str("field identifier")
641				}
642				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
643				where
644					E: de::Error,
645				{
646					match value {
647						"educationRequirements" => Ok(Field::EducationRequirements),
648						"estimatedSalary" => Ok(Field::EstimatedSalary),
649						"experienceRequirements" => Ok(Field::ExperienceRequirements),
650						"occupationLocation" => Ok(Field::OccupationLocation),
651						"occupationalCategory" => Ok(Field::OccupationalCategory),
652						"qualifications" => Ok(Field::Qualifications),
653						"responsibilities" => Ok(Field::Responsibilities),
654						"skills" => Ok(Field::Skills),
655						"additionalType" => Ok(Field::AdditionalType),
656						"alternateName" => Ok(Field::AlternateName),
657						"description" => Ok(Field::Description),
658						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
659						"identifier" => Ok(Field::Identifier),
660						"image" => Ok(Field::Image),
661						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
662						"name" => Ok(Field::Name),
663						"potentialAction" => Ok(Field::PotentialAction),
664						"sameAs" => Ok(Field::SameAs),
665						"subjectOf" => Ok(Field::SubjectOf),
666						"url" => Ok(Field::Url),
667						"id" | "type" => Ok(Field::Ignore),
668						_ => Err(de::Error::unknown_field(value, FIELDS)),
669					}
670				}
671				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
672				where
673					E: de::Error,
674				{
675					match value {
676						b"educationRequirements" => Ok(Field::EducationRequirements),
677						b"estimatedSalary" => Ok(Field::EstimatedSalary),
678						b"experienceRequirements" => Ok(Field::ExperienceRequirements),
679						b"occupationLocation" => Ok(Field::OccupationLocation),
680						b"occupationalCategory" => Ok(Field::OccupationalCategory),
681						b"qualifications" => Ok(Field::Qualifications),
682						b"responsibilities" => Ok(Field::Responsibilities),
683						b"skills" => Ok(Field::Skills),
684						b"additionalType" => Ok(Field::AdditionalType),
685						b"alternateName" => Ok(Field::AlternateName),
686						b"description" => Ok(Field::Description),
687						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
688						b"identifier" => Ok(Field::Identifier),
689						b"image" => Ok(Field::Image),
690						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
691						b"name" => Ok(Field::Name),
692						b"potentialAction" => Ok(Field::PotentialAction),
693						b"sameAs" => Ok(Field::SameAs),
694						b"subjectOf" => Ok(Field::SubjectOf),
695						b"url" => Ok(Field::Url),
696						b"id" | b"type" => Ok(Field::Ignore),
697						_ => {
698							let value = &String::from_utf8_lossy(value);
699							Err(de::Error::unknown_field(value, FIELDS))
700						}
701					}
702				}
703			}
704			impl<'de> Deserialize<'de> for Field {
705				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
706				where
707					D: Deserializer<'de>,
708				{
709					deserializer.deserialize_identifier(FieldVisitor)
710				}
711			}
712			struct ClassVisitor;
713			impl<'de> Visitor<'de> for ClassVisitor {
714				type Value = Occupation;
715				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
716					formatter.write_str("schema.org schema Occupation")
717				}
718				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
719				where
720					A: de::MapAccess<'de>,
721				{
722					let mut r#education_requirements_property = None;
723					let mut r#estimated_salary_property = None;
724					let mut r#experience_requirements_property = None;
725					let mut r#occupation_location_property = None;
726					let mut r#occupational_category_property = None;
727					let mut r#qualifications_property = None;
728					let mut r#responsibilities_property = None;
729					let mut r#skills_property = None;
730					let mut r#additional_type_property = None;
731					let mut r#alternate_name_property = None;
732					let mut r#description_property = None;
733					let mut r#disambiguating_description_property = None;
734					let mut r#identifier_property = None;
735					let mut r#image_property = None;
736					let mut r#main_entity_of_page_property = None;
737					let mut r#name_property = None;
738					let mut r#potential_action_property = None;
739					let mut r#same_as_property = None;
740					let mut r#subject_of_property = None;
741					let mut r#url_property = None;
742					while let Some(key) = map.next_key::<Field>()? {
743						match key {
744							Field::EducationRequirements => {
745								if r#education_requirements_property.is_some() {
746									return Err(<A::Error as de::Error>::duplicate_field(
747										"educationRequirements",
748									));
749								}
750								r#education_requirements_property = Some({
751									struct DeserializeWith(Vec<EducationRequirementsProperty>);
752									impl<'de> Deserialize<'de> for DeserializeWith {
753										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
754										where
755											D: Deserializer<'de>,
756										{
757											Ok(DeserializeWith(serde_with::As::<
758												serde_with::OneOrMany<serde_with::Same>,
759											>::deserialize(deserializer)?))
760										}
761									}
762									match map.next_value::<DeserializeWith>() {
763										Ok(deserialize_with) => deserialize_with.0,
764										Err(err) => {
765											return Err(err);
766										}
767									}
768								});
769							}
770							Field::EstimatedSalary => {
771								if r#estimated_salary_property.is_some() {
772									return Err(<A::Error as de::Error>::duplicate_field(
773										"estimatedSalary",
774									));
775								}
776								r#estimated_salary_property = Some({
777									struct DeserializeWith(Vec<EstimatedSalaryProperty>);
778									impl<'de> Deserialize<'de> for DeserializeWith {
779										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
780										where
781											D: Deserializer<'de>,
782										{
783											Ok(DeserializeWith(serde_with::As::<
784												serde_with::OneOrMany<serde_with::Same>,
785											>::deserialize(deserializer)?))
786										}
787									}
788									match map.next_value::<DeserializeWith>() {
789										Ok(deserialize_with) => deserialize_with.0,
790										Err(err) => {
791											return Err(err);
792										}
793									}
794								});
795							}
796							Field::ExperienceRequirements => {
797								if r#experience_requirements_property.is_some() {
798									return Err(<A::Error as de::Error>::duplicate_field(
799										"experienceRequirements",
800									));
801								}
802								r#experience_requirements_property = Some({
803									struct DeserializeWith(Vec<ExperienceRequirementsProperty>);
804									impl<'de> Deserialize<'de> for DeserializeWith {
805										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
806										where
807											D: Deserializer<'de>,
808										{
809											Ok(DeserializeWith(serde_with::As::<
810												serde_with::OneOrMany<serde_with::Same>,
811											>::deserialize(deserializer)?))
812										}
813									}
814									match map.next_value::<DeserializeWith>() {
815										Ok(deserialize_with) => deserialize_with.0,
816										Err(err) => {
817											return Err(err);
818										}
819									}
820								});
821							}
822							Field::OccupationLocation => {
823								if r#occupation_location_property.is_some() {
824									return Err(<A::Error as de::Error>::duplicate_field(
825										"occupationLocation",
826									));
827								}
828								r#occupation_location_property = Some({
829									struct DeserializeWith(Vec<OccupationLocationProperty>);
830									impl<'de> Deserialize<'de> for DeserializeWith {
831										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
832										where
833											D: Deserializer<'de>,
834										{
835											Ok(DeserializeWith(serde_with::As::<
836												serde_with::OneOrMany<serde_with::Same>,
837											>::deserialize(deserializer)?))
838										}
839									}
840									match map.next_value::<DeserializeWith>() {
841										Ok(deserialize_with) => deserialize_with.0,
842										Err(err) => {
843											return Err(err);
844										}
845									}
846								});
847							}
848							Field::OccupationalCategory => {
849								if r#occupational_category_property.is_some() {
850									return Err(<A::Error as de::Error>::duplicate_field(
851										"occupationalCategory",
852									));
853								}
854								r#occupational_category_property = Some({
855									struct DeserializeWith(Vec<OccupationalCategoryProperty>);
856									impl<'de> Deserialize<'de> for DeserializeWith {
857										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
858										where
859											D: Deserializer<'de>,
860										{
861											Ok(DeserializeWith(serde_with::As::<
862												serde_with::OneOrMany<serde_with::Same>,
863											>::deserialize(deserializer)?))
864										}
865									}
866									match map.next_value::<DeserializeWith>() {
867										Ok(deserialize_with) => deserialize_with.0,
868										Err(err) => {
869											return Err(err);
870										}
871									}
872								});
873							}
874							Field::Qualifications => {
875								if r#qualifications_property.is_some() {
876									return Err(<A::Error as de::Error>::duplicate_field(
877										"qualifications",
878									));
879								}
880								r#qualifications_property = Some({
881									struct DeserializeWith(Vec<QualificationsProperty>);
882									impl<'de> Deserialize<'de> for DeserializeWith {
883										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
884										where
885											D: Deserializer<'de>,
886										{
887											Ok(DeserializeWith(serde_with::As::<
888												serde_with::OneOrMany<serde_with::Same>,
889											>::deserialize(deserializer)?))
890										}
891									}
892									match map.next_value::<DeserializeWith>() {
893										Ok(deserialize_with) => deserialize_with.0,
894										Err(err) => {
895											return Err(err);
896										}
897									}
898								});
899							}
900							Field::Responsibilities => {
901								if r#responsibilities_property.is_some() {
902									return Err(<A::Error as de::Error>::duplicate_field(
903										"responsibilities",
904									));
905								}
906								r#responsibilities_property = Some({
907									struct DeserializeWith(Vec<ResponsibilitiesProperty>);
908									impl<'de> Deserialize<'de> for DeserializeWith {
909										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
910										where
911											D: Deserializer<'de>,
912										{
913											Ok(DeserializeWith(serde_with::As::<
914												serde_with::OneOrMany<serde_with::Same>,
915											>::deserialize(deserializer)?))
916										}
917									}
918									match map.next_value::<DeserializeWith>() {
919										Ok(deserialize_with) => deserialize_with.0,
920										Err(err) => {
921											return Err(err);
922										}
923									}
924								});
925							}
926							Field::Skills => {
927								if r#skills_property.is_some() {
928									return Err(<A::Error as de::Error>::duplicate_field("skills"));
929								}
930								r#skills_property = Some({
931									struct DeserializeWith(Vec<SkillsProperty>);
932									impl<'de> Deserialize<'de> for DeserializeWith {
933										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
934										where
935											D: Deserializer<'de>,
936										{
937											Ok(DeserializeWith(serde_with::As::<
938												serde_with::OneOrMany<serde_with::Same>,
939											>::deserialize(deserializer)?))
940										}
941									}
942									match map.next_value::<DeserializeWith>() {
943										Ok(deserialize_with) => deserialize_with.0,
944										Err(err) => {
945											return Err(err);
946										}
947									}
948								});
949							}
950							Field::AdditionalType => {
951								if r#additional_type_property.is_some() {
952									return Err(<A::Error as de::Error>::duplicate_field(
953										"additionalType",
954									));
955								}
956								r#additional_type_property = Some({
957									struct DeserializeWith(Vec<AdditionalTypeProperty>);
958									impl<'de> Deserialize<'de> for DeserializeWith {
959										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
960										where
961											D: Deserializer<'de>,
962										{
963											Ok(DeserializeWith(serde_with::As::<
964												serde_with::OneOrMany<serde_with::Same>,
965											>::deserialize(deserializer)?))
966										}
967									}
968									match map.next_value::<DeserializeWith>() {
969										Ok(deserialize_with) => deserialize_with.0,
970										Err(err) => {
971											return Err(err);
972										}
973									}
974								});
975							}
976							Field::AlternateName => {
977								if r#alternate_name_property.is_some() {
978									return Err(<A::Error as de::Error>::duplicate_field(
979										"alternateName",
980									));
981								}
982								r#alternate_name_property = Some({
983									struct DeserializeWith(Vec<AlternateNameProperty>);
984									impl<'de> Deserialize<'de> for DeserializeWith {
985										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
986										where
987											D: Deserializer<'de>,
988										{
989											Ok(DeserializeWith(serde_with::As::<
990												serde_with::OneOrMany<serde_with::Same>,
991											>::deserialize(deserializer)?))
992										}
993									}
994									match map.next_value::<DeserializeWith>() {
995										Ok(deserialize_with) => deserialize_with.0,
996										Err(err) => {
997											return Err(err);
998										}
999									}
1000								});
1001							}
1002							Field::Description => {
1003								if r#description_property.is_some() {
1004									return Err(<A::Error as de::Error>::duplicate_field(
1005										"description",
1006									));
1007								}
1008								r#description_property = Some({
1009									struct DeserializeWith(Vec<DescriptionProperty>);
1010									impl<'de> Deserialize<'de> for DeserializeWith {
1011										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1012										where
1013											D: Deserializer<'de>,
1014										{
1015											Ok(DeserializeWith(serde_with::As::<
1016												serde_with::OneOrMany<serde_with::Same>,
1017											>::deserialize(deserializer)?))
1018										}
1019									}
1020									match map.next_value::<DeserializeWith>() {
1021										Ok(deserialize_with) => deserialize_with.0,
1022										Err(err) => {
1023											return Err(err);
1024										}
1025									}
1026								});
1027							}
1028							Field::DisambiguatingDescription => {
1029								if r#disambiguating_description_property.is_some() {
1030									return Err(<A::Error as de::Error>::duplicate_field(
1031										"disambiguatingDescription",
1032									));
1033								}
1034								r#disambiguating_description_property = Some({
1035									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1036									impl<'de> Deserialize<'de> for DeserializeWith {
1037										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1038										where
1039											D: Deserializer<'de>,
1040										{
1041											Ok(DeserializeWith(serde_with::As::<
1042												serde_with::OneOrMany<serde_with::Same>,
1043											>::deserialize(deserializer)?))
1044										}
1045									}
1046									match map.next_value::<DeserializeWith>() {
1047										Ok(deserialize_with) => deserialize_with.0,
1048										Err(err) => {
1049											return Err(err);
1050										}
1051									}
1052								});
1053							}
1054							Field::Identifier => {
1055								if r#identifier_property.is_some() {
1056									return Err(<A::Error as de::Error>::duplicate_field(
1057										"identifier",
1058									));
1059								}
1060								r#identifier_property = Some({
1061									struct DeserializeWith(Vec<IdentifierProperty>);
1062									impl<'de> Deserialize<'de> for DeserializeWith {
1063										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1064										where
1065											D: Deserializer<'de>,
1066										{
1067											Ok(DeserializeWith(serde_with::As::<
1068												serde_with::OneOrMany<serde_with::Same>,
1069											>::deserialize(deserializer)?))
1070										}
1071									}
1072									match map.next_value::<DeserializeWith>() {
1073										Ok(deserialize_with) => deserialize_with.0,
1074										Err(err) => {
1075											return Err(err);
1076										}
1077									}
1078								});
1079							}
1080							Field::Image => {
1081								if r#image_property.is_some() {
1082									return Err(<A::Error as de::Error>::duplicate_field("image"));
1083								}
1084								r#image_property = Some({
1085									struct DeserializeWith(Vec<ImageProperty>);
1086									impl<'de> Deserialize<'de> for DeserializeWith {
1087										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1088										where
1089											D: Deserializer<'de>,
1090										{
1091											Ok(DeserializeWith(serde_with::As::<
1092												serde_with::OneOrMany<serde_with::Same>,
1093											>::deserialize(deserializer)?))
1094										}
1095									}
1096									match map.next_value::<DeserializeWith>() {
1097										Ok(deserialize_with) => deserialize_with.0,
1098										Err(err) => {
1099											return Err(err);
1100										}
1101									}
1102								});
1103							}
1104							Field::MainEntityOfPage => {
1105								if r#main_entity_of_page_property.is_some() {
1106									return Err(<A::Error as de::Error>::duplicate_field(
1107										"mainEntityOfPage",
1108									));
1109								}
1110								r#main_entity_of_page_property = Some({
1111									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1112									impl<'de> Deserialize<'de> for DeserializeWith {
1113										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1114										where
1115											D: Deserializer<'de>,
1116										{
1117											Ok(DeserializeWith(serde_with::As::<
1118												serde_with::OneOrMany<serde_with::Same>,
1119											>::deserialize(deserializer)?))
1120										}
1121									}
1122									match map.next_value::<DeserializeWith>() {
1123										Ok(deserialize_with) => deserialize_with.0,
1124										Err(err) => {
1125											return Err(err);
1126										}
1127									}
1128								});
1129							}
1130							Field::Name => {
1131								if r#name_property.is_some() {
1132									return Err(<A::Error as de::Error>::duplicate_field("name"));
1133								}
1134								r#name_property = Some({
1135									struct DeserializeWith(Vec<NameProperty>);
1136									impl<'de> Deserialize<'de> for DeserializeWith {
1137										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1138										where
1139											D: Deserializer<'de>,
1140										{
1141											Ok(DeserializeWith(serde_with::As::<
1142												serde_with::OneOrMany<serde_with::Same>,
1143											>::deserialize(deserializer)?))
1144										}
1145									}
1146									match map.next_value::<DeserializeWith>() {
1147										Ok(deserialize_with) => deserialize_with.0,
1148										Err(err) => {
1149											return Err(err);
1150										}
1151									}
1152								});
1153							}
1154							Field::PotentialAction => {
1155								if r#potential_action_property.is_some() {
1156									return Err(<A::Error as de::Error>::duplicate_field(
1157										"potentialAction",
1158									));
1159								}
1160								r#potential_action_property = Some({
1161									struct DeserializeWith(Vec<PotentialActionProperty>);
1162									impl<'de> Deserialize<'de> for DeserializeWith {
1163										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1164										where
1165											D: Deserializer<'de>,
1166										{
1167											Ok(DeserializeWith(serde_with::As::<
1168												serde_with::OneOrMany<serde_with::Same>,
1169											>::deserialize(deserializer)?))
1170										}
1171									}
1172									match map.next_value::<DeserializeWith>() {
1173										Ok(deserialize_with) => deserialize_with.0,
1174										Err(err) => {
1175											return Err(err);
1176										}
1177									}
1178								});
1179							}
1180							Field::SameAs => {
1181								if r#same_as_property.is_some() {
1182									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1183								}
1184								r#same_as_property = Some({
1185									struct DeserializeWith(Vec<SameAsProperty>);
1186									impl<'de> Deserialize<'de> for DeserializeWith {
1187										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1188										where
1189											D: Deserializer<'de>,
1190										{
1191											Ok(DeserializeWith(serde_with::As::<
1192												serde_with::OneOrMany<serde_with::Same>,
1193											>::deserialize(deserializer)?))
1194										}
1195									}
1196									match map.next_value::<DeserializeWith>() {
1197										Ok(deserialize_with) => deserialize_with.0,
1198										Err(err) => {
1199											return Err(err);
1200										}
1201									}
1202								});
1203							}
1204							Field::SubjectOf => {
1205								if r#subject_of_property.is_some() {
1206									return Err(<A::Error as de::Error>::duplicate_field(
1207										"subjectOf",
1208									));
1209								}
1210								r#subject_of_property = Some({
1211									struct DeserializeWith(Vec<SubjectOfProperty>);
1212									impl<'de> Deserialize<'de> for DeserializeWith {
1213										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1214										where
1215											D: Deserializer<'de>,
1216										{
1217											Ok(DeserializeWith(serde_with::As::<
1218												serde_with::OneOrMany<serde_with::Same>,
1219											>::deserialize(deserializer)?))
1220										}
1221									}
1222									match map.next_value::<DeserializeWith>() {
1223										Ok(deserialize_with) => deserialize_with.0,
1224										Err(err) => {
1225											return Err(err);
1226										}
1227									}
1228								});
1229							}
1230							Field::Url => {
1231								if r#url_property.is_some() {
1232									return Err(<A::Error as de::Error>::duplicate_field("url"));
1233								}
1234								r#url_property = Some({
1235									struct DeserializeWith(Vec<UrlProperty>);
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::Ignore => {
1255								let _ = map.next_value::<de::IgnoredAny>()?;
1256							}
1257						}
1258					}
1259					Ok(Occupation {
1260						r#education_requirements: r#education_requirements_property
1261							.unwrap_or_default(),
1262						r#estimated_salary: r#estimated_salary_property.unwrap_or_default(),
1263						r#experience_requirements: r#experience_requirements_property
1264							.unwrap_or_default(),
1265						r#occupation_location: r#occupation_location_property.unwrap_or_default(),
1266						r#occupational_category: r#occupational_category_property
1267							.unwrap_or_default(),
1268						r#qualifications: r#qualifications_property.unwrap_or_default(),
1269						r#responsibilities: r#responsibilities_property.unwrap_or_default(),
1270						r#skills: r#skills_property.unwrap_or_default(),
1271						r#additional_type: r#additional_type_property.unwrap_or_default(),
1272						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1273						r#description: r#description_property.unwrap_or_default(),
1274						r#disambiguating_description: r#disambiguating_description_property
1275							.unwrap_or_default(),
1276						r#identifier: r#identifier_property.unwrap_or_default(),
1277						r#image: r#image_property.unwrap_or_default(),
1278						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1279						r#name: r#name_property.unwrap_or_default(),
1280						r#potential_action: r#potential_action_property.unwrap_or_default(),
1281						r#same_as: r#same_as_property.unwrap_or_default(),
1282						r#subject_of: r#subject_of_property.unwrap_or_default(),
1283						r#url: r#url_property.unwrap_or_default(),
1284					})
1285				}
1286			}
1287			const FIELDS: &[&str] = &[
1288				"educationRequirements",
1289				"estimatedSalary",
1290				"experienceRequirements",
1291				"occupationLocation",
1292				"occupationalCategory",
1293				"qualifications",
1294				"responsibilities",
1295				"skills",
1296				"additionalType",
1297				"alternateName",
1298				"description",
1299				"disambiguatingDescription",
1300				"identifier",
1301				"image",
1302				"mainEntityOfPage",
1303				"name",
1304				"potentialAction",
1305				"sameAs",
1306				"subjectOf",
1307				"url",
1308			];
1309			deserializer.deserialize_struct("Occupation", FIELDS, ClassVisitor)
1310		}
1311	}
1312}
schema_org_types/schemas/classes/occupation.rs

schema_org_types/schemas/classes/
occupation.rs
