schema_org_types/schemas/classes/
person.rs

1use super::*;
2/// <https://schema.org/Person>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Person {
6	/// <https://schema.org/additionalName>
7	pub r#additional_name: Vec<AdditionalNameProperty>,
8	/// <https://schema.org/address>
9	pub r#address: Vec<AddressProperty>,
10	/// <https://schema.org/affiliation>
11	pub r#affiliation: Vec<AffiliationProperty>,
12	/// <https://schema.org/agentInteractionStatistic>
13	pub r#agent_interaction_statistic: Vec<AgentInteractionStatisticProperty>,
14	/// <https://schema.org/alumniOf>
15	pub r#alumni_of: Vec<AlumniOfProperty>,
16	/// <https://schema.org/award>
17	pub r#award: Vec<AwardProperty>,
18	/// <https://schema.org/awards>
19	#[deprecated = "This schema is superseded by <https://schema.org/award>."]
20	pub r#awards: Vec<AwardsProperty>,
21	/// <https://schema.org/birthDate>
22	pub r#birth_date: Vec<BirthDateProperty>,
23	/// <https://schema.org/birthPlace>
24	pub r#birth_place: Vec<BirthPlaceProperty>,
25	/// <https://schema.org/brand>
26	pub r#brand: Vec<BrandProperty>,
27	/// <https://schema.org/callSign>
28	pub r#call_sign: Vec<CallSignProperty>,
29	/// <https://schema.org/children>
30	pub r#children: Vec<ChildrenProperty>,
31	/// <https://schema.org/colleague>
32	pub r#colleague: Vec<ColleagueProperty>,
33	/// <https://schema.org/colleagues>
34	#[deprecated = "This schema is superseded by <https://schema.org/colleague>."]
35	pub r#colleagues: Vec<ColleaguesProperty>,
36	/// <https://schema.org/contactPoint>
37	pub r#contact_point: Vec<ContactPointProperty>,
38	/// <https://schema.org/contactPoints>
39	#[deprecated = "This schema is superseded by <https://schema.org/contactPoint>."]
40	pub r#contact_points: Vec<ContactPointsProperty>,
41	/// <https://schema.org/deathDate>
42	pub r#death_date: Vec<DeathDateProperty>,
43	/// <https://schema.org/deathPlace>
44	pub r#death_place: Vec<DeathPlaceProperty>,
45	/// <https://schema.org/duns>
46	pub r#duns: Vec<DunsProperty>,
47	/// <https://schema.org/email>
48	pub r#email: Vec<EmailProperty>,
49	/// <https://schema.org/familyName>
50	pub r#family_name: Vec<FamilyNameProperty>,
51	/// <https://schema.org/faxNumber>
52	pub r#fax_number: Vec<FaxNumberProperty>,
53	/// <https://schema.org/follows>
54	pub r#follows: Vec<FollowsProperty>,
55	/// <https://schema.org/funder>
56	pub r#funder: Vec<FunderProperty>,
57	/// <https://schema.org/funding>
58	pub r#funding: Vec<FundingProperty>,
59	/// <https://schema.org/gender>
60	pub r#gender: Vec<GenderProperty>,
61	/// <https://schema.org/givenName>
62	pub r#given_name: Vec<GivenNameProperty>,
63	/// <https://schema.org/globalLocationNumber>
64	pub r#global_location_number: Vec<GlobalLocationNumberProperty>,
65	/// <https://schema.org/hasCredential>
66	pub r#has_credential: Vec<HasCredentialProperty>,
67	/// <https://schema.org/hasOccupation>
68	pub r#has_occupation: Vec<HasOccupationProperty>,
69	/// <https://schema.org/hasOfferCatalog>
70	pub r#has_offer_catalog: Vec<HasOfferCatalogProperty>,
71	/// <https://schema.org/hasPOS>
72	pub r#has_pos: Vec<HasPosProperty>,
73	/// <https://schema.org/height>
74	pub r#height: Vec<HeightProperty>,
75	/// <https://schema.org/homeLocation>
76	pub r#home_location: Vec<HomeLocationProperty>,
77	/// <https://schema.org/honorificPrefix>
78	pub r#honorific_prefix: Vec<HonorificPrefixProperty>,
79	/// <https://schema.org/honorificSuffix>
80	pub r#honorific_suffix: Vec<HonorificSuffixProperty>,
81	/// <https://schema.org/interactionStatistic>
82	pub r#interaction_statistic: Vec<InteractionStatisticProperty>,
83	/// <https://schema.org/isicV4>
84	pub r#isic_v_4: Vec<IsicV4Property>,
85	/// <https://schema.org/jobTitle>
86	pub r#job_title: Vec<JobTitleProperty>,
87	/// <https://schema.org/knows>
88	pub r#knows: Vec<KnowsProperty>,
89	/// <https://schema.org/knowsAbout>
90	pub r#knows_about: Vec<KnowsAboutProperty>,
91	/// <https://schema.org/knowsLanguage>
92	pub r#knows_language: Vec<KnowsLanguageProperty>,
93	/// <https://schema.org/makesOffer>
94	pub r#makes_offer: Vec<MakesOfferProperty>,
95	/// <https://schema.org/memberOf>
96	pub r#member_of: Vec<MemberOfProperty>,
97	/// <https://schema.org/naics>
98	pub r#naics: Vec<NaicsProperty>,
99	/// <https://schema.org/nationality>
100	pub r#nationality: Vec<NationalityProperty>,
101	/// <https://schema.org/netWorth>
102	pub r#net_worth: Vec<NetWorthProperty>,
103	/// <https://schema.org/owns>
104	pub r#owns: Vec<OwnsProperty>,
105	/// <https://schema.org/parent>
106	pub r#parent: Vec<ParentProperty>,
107	/// <https://schema.org/parents>
108	#[deprecated = "This schema is superseded by <https://schema.org/parent>."]
109	pub r#parents: Vec<ParentsProperty>,
110	/// <https://schema.org/performerIn>
111	pub r#performer_in: Vec<PerformerInProperty>,
112	/// <https://schema.org/publishingPrinciples>
113	pub r#publishing_principles: Vec<PublishingPrinciplesProperty>,
114	/// <https://schema.org/relatedTo>
115	pub r#related_to: Vec<RelatedToProperty>,
116	/// <https://schema.org/seeks>
117	pub r#seeks: Vec<SeeksProperty>,
118	/// <https://schema.org/sibling>
119	pub r#sibling: Vec<SiblingProperty>,
120	/// <https://schema.org/siblings>
121	#[deprecated = "This schema is superseded by <https://schema.org/sibling>."]
122	pub r#siblings: Vec<SiblingsProperty>,
123	/// <https://schema.org/sponsor>
124	pub r#sponsor: Vec<SponsorProperty>,
125	/// <https://schema.org/spouse>
126	pub r#spouse: Vec<SpouseProperty>,
127	/// <https://schema.org/taxID>
128	pub r#tax_id: Vec<TaxIdProperty>,
129	/// <https://schema.org/telephone>
130	pub r#telephone: Vec<TelephoneProperty>,
131	/// <https://schema.org/vatID>
132	pub r#vat_id: Vec<VatIdProperty>,
133	/// <https://schema.org/weight>
134	pub r#weight: Vec<WeightProperty>,
135	/// <https://schema.org/workLocation>
136	pub r#work_location: Vec<WorkLocationProperty>,
137	/// <https://schema.org/worksFor>
138	pub r#works_for: Vec<WorksForProperty>,
139	/// <https://schema.org/additionalType>
140	pub r#additional_type: Vec<AdditionalTypeProperty>,
141	/// <https://schema.org/alternateName>
142	pub r#alternate_name: Vec<AlternateNameProperty>,
143	/// <https://schema.org/description>
144	pub r#description: Vec<DescriptionProperty>,
145	/// <https://schema.org/disambiguatingDescription>
146	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
147	/// <https://schema.org/identifier>
148	pub r#identifier: Vec<IdentifierProperty>,
149	/// <https://schema.org/image>
150	pub r#image: Vec<ImageProperty>,
151	/// <https://schema.org/mainEntityOfPage>
152	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
153	/// <https://schema.org/name>
154	pub r#name: Vec<NameProperty>,
155	/// <https://schema.org/potentialAction>
156	pub r#potential_action: Vec<PotentialActionProperty>,
157	/// <https://schema.org/sameAs>
158	pub r#same_as: Vec<SameAsProperty>,
159	/// <https://schema.org/subjectOf>
160	pub r#subject_of: Vec<SubjectOfProperty>,
161	/// <https://schema.org/url>
162	pub r#url: Vec<UrlProperty>,
163}
164/// This trait is for properties from <https://schema.org/Person>.
165pub trait PersonTrait {
166	/// Get <https://schema.org/additionalName> from [`Self`] as borrowed slice.
167	fn get_additional_name(&self) -> &[AdditionalNameProperty];
168	/// Take <https://schema.org/additionalName> from [`Self`] as owned vector.
169	fn take_additional_name(&mut self) -> Vec<AdditionalNameProperty>;
170	/// Get <https://schema.org/address> from [`Self`] as borrowed slice.
171	fn get_address(&self) -> &[AddressProperty];
172	/// Take <https://schema.org/address> from [`Self`] as owned vector.
173	fn take_address(&mut self) -> Vec<AddressProperty>;
174	/// Get <https://schema.org/affiliation> from [`Self`] as borrowed slice.
175	fn get_affiliation(&self) -> &[AffiliationProperty];
176	/// Take <https://schema.org/affiliation> from [`Self`] as owned vector.
177	fn take_affiliation(&mut self) -> Vec<AffiliationProperty>;
178	/// Get <https://schema.org/agentInteractionStatistic> from [`Self`] as borrowed slice.
179	fn get_agent_interaction_statistic(&self) -> &[AgentInteractionStatisticProperty];
180	/// Take <https://schema.org/agentInteractionStatistic> from [`Self`] as owned vector.
181	fn take_agent_interaction_statistic(&mut self) -> Vec<AgentInteractionStatisticProperty>;
182	/// Get <https://schema.org/alumniOf> from [`Self`] as borrowed slice.
183	fn get_alumni_of(&self) -> &[AlumniOfProperty];
184	/// Take <https://schema.org/alumniOf> from [`Self`] as owned vector.
185	fn take_alumni_of(&mut self) -> Vec<AlumniOfProperty>;
186	/// Get <https://schema.org/award> from [`Self`] as borrowed slice.
187	fn get_award(&self) -> &[AwardProperty];
188	/// Take <https://schema.org/award> from [`Self`] as owned vector.
189	fn take_award(&mut self) -> Vec<AwardProperty>;
190	/// Get <https://schema.org/awards> from [`Self`] as borrowed slice.
191	#[deprecated = "This schema is superseded by <https://schema.org/award>."]
192	fn get_awards(&self) -> &[AwardsProperty];
193	/// Take <https://schema.org/awards> from [`Self`] as owned vector.
194	#[deprecated = "This schema is superseded by <https://schema.org/award>."]
195	fn take_awards(&mut self) -> Vec<AwardsProperty>;
196	/// Get <https://schema.org/birthDate> from [`Self`] as borrowed slice.
197	fn get_birth_date(&self) -> &[BirthDateProperty];
198	/// Take <https://schema.org/birthDate> from [`Self`] as owned vector.
199	fn take_birth_date(&mut self) -> Vec<BirthDateProperty>;
200	/// Get <https://schema.org/birthPlace> from [`Self`] as borrowed slice.
201	fn get_birth_place(&self) -> &[BirthPlaceProperty];
202	/// Take <https://schema.org/birthPlace> from [`Self`] as owned vector.
203	fn take_birth_place(&mut self) -> Vec<BirthPlaceProperty>;
204	/// Get <https://schema.org/brand> from [`Self`] as borrowed slice.
205	fn get_brand(&self) -> &[BrandProperty];
206	/// Take <https://schema.org/brand> from [`Self`] as owned vector.
207	fn take_brand(&mut self) -> Vec<BrandProperty>;
208	/// Get <https://schema.org/callSign> from [`Self`] as borrowed slice.
209	fn get_call_sign(&self) -> &[CallSignProperty];
210	/// Take <https://schema.org/callSign> from [`Self`] as owned vector.
211	fn take_call_sign(&mut self) -> Vec<CallSignProperty>;
212	/// Get <https://schema.org/children> from [`Self`] as borrowed slice.
213	fn get_children(&self) -> &[ChildrenProperty];
214	/// Take <https://schema.org/children> from [`Self`] as owned vector.
215	fn take_children(&mut self) -> Vec<ChildrenProperty>;
216	/// Get <https://schema.org/colleague> from [`Self`] as borrowed slice.
217	fn get_colleague(&self) -> &[ColleagueProperty];
218	/// Take <https://schema.org/colleague> from [`Self`] as owned vector.
219	fn take_colleague(&mut self) -> Vec<ColleagueProperty>;
220	/// Get <https://schema.org/colleagues> from [`Self`] as borrowed slice.
221	#[deprecated = "This schema is superseded by <https://schema.org/colleague>."]
222	fn get_colleagues(&self) -> &[ColleaguesProperty];
223	/// Take <https://schema.org/colleagues> from [`Self`] as owned vector.
224	#[deprecated = "This schema is superseded by <https://schema.org/colleague>."]
225	fn take_colleagues(&mut self) -> Vec<ColleaguesProperty>;
226	/// Get <https://schema.org/contactPoint> from [`Self`] as borrowed slice.
227	fn get_contact_point(&self) -> &[ContactPointProperty];
228	/// Take <https://schema.org/contactPoint> from [`Self`] as owned vector.
229	fn take_contact_point(&mut self) -> Vec<ContactPointProperty>;
230	/// Get <https://schema.org/contactPoints> from [`Self`] as borrowed slice.
231	#[deprecated = "This schema is superseded by <https://schema.org/contactPoint>."]
232	fn get_contact_points(&self) -> &[ContactPointsProperty];
233	/// Take <https://schema.org/contactPoints> from [`Self`] as owned vector.
234	#[deprecated = "This schema is superseded by <https://schema.org/contactPoint>."]
235	fn take_contact_points(&mut self) -> Vec<ContactPointsProperty>;
236	/// Get <https://schema.org/deathDate> from [`Self`] as borrowed slice.
237	fn get_death_date(&self) -> &[DeathDateProperty];
238	/// Take <https://schema.org/deathDate> from [`Self`] as owned vector.
239	fn take_death_date(&mut self) -> Vec<DeathDateProperty>;
240	/// Get <https://schema.org/deathPlace> from [`Self`] as borrowed slice.
241	fn get_death_place(&self) -> &[DeathPlaceProperty];
242	/// Take <https://schema.org/deathPlace> from [`Self`] as owned vector.
243	fn take_death_place(&mut self) -> Vec<DeathPlaceProperty>;
244	/// Get <https://schema.org/duns> from [`Self`] as borrowed slice.
245	fn get_duns(&self) -> &[DunsProperty];
246	/// Take <https://schema.org/duns> from [`Self`] as owned vector.
247	fn take_duns(&mut self) -> Vec<DunsProperty>;
248	/// Get <https://schema.org/email> from [`Self`] as borrowed slice.
249	fn get_email(&self) -> &[EmailProperty];
250	/// Take <https://schema.org/email> from [`Self`] as owned vector.
251	fn take_email(&mut self) -> Vec<EmailProperty>;
252	/// Get <https://schema.org/familyName> from [`Self`] as borrowed slice.
253	fn get_family_name(&self) -> &[FamilyNameProperty];
254	/// Take <https://schema.org/familyName> from [`Self`] as owned vector.
255	fn take_family_name(&mut self) -> Vec<FamilyNameProperty>;
256	/// Get <https://schema.org/faxNumber> from [`Self`] as borrowed slice.
257	fn get_fax_number(&self) -> &[FaxNumberProperty];
258	/// Take <https://schema.org/faxNumber> from [`Self`] as owned vector.
259	fn take_fax_number(&mut self) -> Vec<FaxNumberProperty>;
260	/// Get <https://schema.org/follows> from [`Self`] as borrowed slice.
261	fn get_follows(&self) -> &[FollowsProperty];
262	/// Take <https://schema.org/follows> from [`Self`] as owned vector.
263	fn take_follows(&mut self) -> Vec<FollowsProperty>;
264	/// Get <https://schema.org/funder> from [`Self`] as borrowed slice.
265	fn get_funder(&self) -> &[FunderProperty];
266	/// Take <https://schema.org/funder> from [`Self`] as owned vector.
267	fn take_funder(&mut self) -> Vec<FunderProperty>;
268	/// Get <https://schema.org/funding> from [`Self`] as borrowed slice.
269	fn get_funding(&self) -> &[FundingProperty];
270	/// Take <https://schema.org/funding> from [`Self`] as owned vector.
271	fn take_funding(&mut self) -> Vec<FundingProperty>;
272	/// Get <https://schema.org/gender> from [`Self`] as borrowed slice.
273	fn get_gender(&self) -> &[GenderProperty];
274	/// Take <https://schema.org/gender> from [`Self`] as owned vector.
275	fn take_gender(&mut self) -> Vec<GenderProperty>;
276	/// Get <https://schema.org/givenName> from [`Self`] as borrowed slice.
277	fn get_given_name(&self) -> &[GivenNameProperty];
278	/// Take <https://schema.org/givenName> from [`Self`] as owned vector.
279	fn take_given_name(&mut self) -> Vec<GivenNameProperty>;
280	/// Get <https://schema.org/globalLocationNumber> from [`Self`] as borrowed slice.
281	fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty];
282	/// Take <https://schema.org/globalLocationNumber> from [`Self`] as owned vector.
283	fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty>;
284	/// Get <https://schema.org/hasCredential> from [`Self`] as borrowed slice.
285	fn get_has_credential(&self) -> &[HasCredentialProperty];
286	/// Take <https://schema.org/hasCredential> from [`Self`] as owned vector.
287	fn take_has_credential(&mut self) -> Vec<HasCredentialProperty>;
288	/// Get <https://schema.org/hasOccupation> from [`Self`] as borrowed slice.
289	fn get_has_occupation(&self) -> &[HasOccupationProperty];
290	/// Take <https://schema.org/hasOccupation> from [`Self`] as owned vector.
291	fn take_has_occupation(&mut self) -> Vec<HasOccupationProperty>;
292	/// Get <https://schema.org/hasOfferCatalog> from [`Self`] as borrowed slice.
293	fn get_has_offer_catalog(&self) -> &[HasOfferCatalogProperty];
294	/// Take <https://schema.org/hasOfferCatalog> from [`Self`] as owned vector.
295	fn take_has_offer_catalog(&mut self) -> Vec<HasOfferCatalogProperty>;
296	/// Get <https://schema.org/hasPOS> from [`Self`] as borrowed slice.
297	fn get_has_pos(&self) -> &[HasPosProperty];
298	/// Take <https://schema.org/hasPOS> from [`Self`] as owned vector.
299	fn take_has_pos(&mut self) -> Vec<HasPosProperty>;
300	/// Get <https://schema.org/height> from [`Self`] as borrowed slice.
301	fn get_height(&self) -> &[HeightProperty];
302	/// Take <https://schema.org/height> from [`Self`] as owned vector.
303	fn take_height(&mut self) -> Vec<HeightProperty>;
304	/// Get <https://schema.org/homeLocation> from [`Self`] as borrowed slice.
305	fn get_home_location(&self) -> &[HomeLocationProperty];
306	/// Take <https://schema.org/homeLocation> from [`Self`] as owned vector.
307	fn take_home_location(&mut self) -> Vec<HomeLocationProperty>;
308	/// Get <https://schema.org/honorificPrefix> from [`Self`] as borrowed slice.
309	fn get_honorific_prefix(&self) -> &[HonorificPrefixProperty];
310	/// Take <https://schema.org/honorificPrefix> from [`Self`] as owned vector.
311	fn take_honorific_prefix(&mut self) -> Vec<HonorificPrefixProperty>;
312	/// Get <https://schema.org/honorificSuffix> from [`Self`] as borrowed slice.
313	fn get_honorific_suffix(&self) -> &[HonorificSuffixProperty];
314	/// Take <https://schema.org/honorificSuffix> from [`Self`] as owned vector.
315	fn take_honorific_suffix(&mut self) -> Vec<HonorificSuffixProperty>;
316	/// Get <https://schema.org/interactionStatistic> from [`Self`] as borrowed slice.
317	fn get_interaction_statistic(&self) -> &[InteractionStatisticProperty];
318	/// Take <https://schema.org/interactionStatistic> from [`Self`] as owned vector.
319	fn take_interaction_statistic(&mut self) -> Vec<InteractionStatisticProperty>;
320	/// Get <https://schema.org/isicV4> from [`Self`] as borrowed slice.
321	fn get_isic_v_4(&self) -> &[IsicV4Property];
322	/// Take <https://schema.org/isicV4> from [`Self`] as owned vector.
323	fn take_isic_v_4(&mut self) -> Vec<IsicV4Property>;
324	/// Get <https://schema.org/jobTitle> from [`Self`] as borrowed slice.
325	fn get_job_title(&self) -> &[JobTitleProperty];
326	/// Take <https://schema.org/jobTitle> from [`Self`] as owned vector.
327	fn take_job_title(&mut self) -> Vec<JobTitleProperty>;
328	/// Get <https://schema.org/knows> from [`Self`] as borrowed slice.
329	fn get_knows(&self) -> &[KnowsProperty];
330	/// Take <https://schema.org/knows> from [`Self`] as owned vector.
331	fn take_knows(&mut self) -> Vec<KnowsProperty>;
332	/// Get <https://schema.org/knowsAbout> from [`Self`] as borrowed slice.
333	fn get_knows_about(&self) -> &[KnowsAboutProperty];
334	/// Take <https://schema.org/knowsAbout> from [`Self`] as owned vector.
335	fn take_knows_about(&mut self) -> Vec<KnowsAboutProperty>;
336	/// Get <https://schema.org/knowsLanguage> from [`Self`] as borrowed slice.
337	fn get_knows_language(&self) -> &[KnowsLanguageProperty];
338	/// Take <https://schema.org/knowsLanguage> from [`Self`] as owned vector.
339	fn take_knows_language(&mut self) -> Vec<KnowsLanguageProperty>;
340	/// Get <https://schema.org/makesOffer> from [`Self`] as borrowed slice.
341	fn get_makes_offer(&self) -> &[MakesOfferProperty];
342	/// Take <https://schema.org/makesOffer> from [`Self`] as owned vector.
343	fn take_makes_offer(&mut self) -> Vec<MakesOfferProperty>;
344	/// Get <https://schema.org/memberOf> from [`Self`] as borrowed slice.
345	fn get_member_of(&self) -> &[MemberOfProperty];
346	/// Take <https://schema.org/memberOf> from [`Self`] as owned vector.
347	fn take_member_of(&mut self) -> Vec<MemberOfProperty>;
348	/// Get <https://schema.org/naics> from [`Self`] as borrowed slice.
349	fn get_naics(&self) -> &[NaicsProperty];
350	/// Take <https://schema.org/naics> from [`Self`] as owned vector.
351	fn take_naics(&mut self) -> Vec<NaicsProperty>;
352	/// Get <https://schema.org/nationality> from [`Self`] as borrowed slice.
353	fn get_nationality(&self) -> &[NationalityProperty];
354	/// Take <https://schema.org/nationality> from [`Self`] as owned vector.
355	fn take_nationality(&mut self) -> Vec<NationalityProperty>;
356	/// Get <https://schema.org/netWorth> from [`Self`] as borrowed slice.
357	fn get_net_worth(&self) -> &[NetWorthProperty];
358	/// Take <https://schema.org/netWorth> from [`Self`] as owned vector.
359	fn take_net_worth(&mut self) -> Vec<NetWorthProperty>;
360	/// Get <https://schema.org/owns> from [`Self`] as borrowed slice.
361	fn get_owns(&self) -> &[OwnsProperty];
362	/// Take <https://schema.org/owns> from [`Self`] as owned vector.
363	fn take_owns(&mut self) -> Vec<OwnsProperty>;
364	/// Get <https://schema.org/parent> from [`Self`] as borrowed slice.
365	fn get_parent(&self) -> &[ParentProperty];
366	/// Take <https://schema.org/parent> from [`Self`] as owned vector.
367	fn take_parent(&mut self) -> Vec<ParentProperty>;
368	/// Get <https://schema.org/parents> from [`Self`] as borrowed slice.
369	#[deprecated = "This schema is superseded by <https://schema.org/parent>."]
370	fn get_parents(&self) -> &[ParentsProperty];
371	/// Take <https://schema.org/parents> from [`Self`] as owned vector.
372	#[deprecated = "This schema is superseded by <https://schema.org/parent>."]
373	fn take_parents(&mut self) -> Vec<ParentsProperty>;
374	/// Get <https://schema.org/performerIn> from [`Self`] as borrowed slice.
375	fn get_performer_in(&self) -> &[PerformerInProperty];
376	/// Take <https://schema.org/performerIn> from [`Self`] as owned vector.
377	fn take_performer_in(&mut self) -> Vec<PerformerInProperty>;
378	/// Get <https://schema.org/publishingPrinciples> from [`Self`] as borrowed slice.
379	fn get_publishing_principles(&self) -> &[PublishingPrinciplesProperty];
380	/// Take <https://schema.org/publishingPrinciples> from [`Self`] as owned vector.
381	fn take_publishing_principles(&mut self) -> Vec<PublishingPrinciplesProperty>;
382	/// Get <https://schema.org/relatedTo> from [`Self`] as borrowed slice.
383	fn get_related_to(&self) -> &[RelatedToProperty];
384	/// Take <https://schema.org/relatedTo> from [`Self`] as owned vector.
385	fn take_related_to(&mut self) -> Vec<RelatedToProperty>;
386	/// Get <https://schema.org/seeks> from [`Self`] as borrowed slice.
387	fn get_seeks(&self) -> &[SeeksProperty];
388	/// Take <https://schema.org/seeks> from [`Self`] as owned vector.
389	fn take_seeks(&mut self) -> Vec<SeeksProperty>;
390	/// Get <https://schema.org/sibling> from [`Self`] as borrowed slice.
391	fn get_sibling(&self) -> &[SiblingProperty];
392	/// Take <https://schema.org/sibling> from [`Self`] as owned vector.
393	fn take_sibling(&mut self) -> Vec<SiblingProperty>;
394	/// Get <https://schema.org/siblings> from [`Self`] as borrowed slice.
395	#[deprecated = "This schema is superseded by <https://schema.org/sibling>."]
396	fn get_siblings(&self) -> &[SiblingsProperty];
397	/// Take <https://schema.org/siblings> from [`Self`] as owned vector.
398	#[deprecated = "This schema is superseded by <https://schema.org/sibling>."]
399	fn take_siblings(&mut self) -> Vec<SiblingsProperty>;
400	/// Get <https://schema.org/sponsor> from [`Self`] as borrowed slice.
401	fn get_sponsor(&self) -> &[SponsorProperty];
402	/// Take <https://schema.org/sponsor> from [`Self`] as owned vector.
403	fn take_sponsor(&mut self) -> Vec<SponsorProperty>;
404	/// Get <https://schema.org/spouse> from [`Self`] as borrowed slice.
405	fn get_spouse(&self) -> &[SpouseProperty];
406	/// Take <https://schema.org/spouse> from [`Self`] as owned vector.
407	fn take_spouse(&mut self) -> Vec<SpouseProperty>;
408	/// Get <https://schema.org/taxID> from [`Self`] as borrowed slice.
409	fn get_tax_id(&self) -> &[TaxIdProperty];
410	/// Take <https://schema.org/taxID> from [`Self`] as owned vector.
411	fn take_tax_id(&mut self) -> Vec<TaxIdProperty>;
412	/// Get <https://schema.org/telephone> from [`Self`] as borrowed slice.
413	fn get_telephone(&self) -> &[TelephoneProperty];
414	/// Take <https://schema.org/telephone> from [`Self`] as owned vector.
415	fn take_telephone(&mut self) -> Vec<TelephoneProperty>;
416	/// Get <https://schema.org/vatID> from [`Self`] as borrowed slice.
417	fn get_vat_id(&self) -> &[VatIdProperty];
418	/// Take <https://schema.org/vatID> from [`Self`] as owned vector.
419	fn take_vat_id(&mut self) -> Vec<VatIdProperty>;
420	/// Get <https://schema.org/weight> from [`Self`] as borrowed slice.
421	fn get_weight(&self) -> &[WeightProperty];
422	/// Take <https://schema.org/weight> from [`Self`] as owned vector.
423	fn take_weight(&mut self) -> Vec<WeightProperty>;
424	/// Get <https://schema.org/workLocation> from [`Self`] as borrowed slice.
425	fn get_work_location(&self) -> &[WorkLocationProperty];
426	/// Take <https://schema.org/workLocation> from [`Self`] as owned vector.
427	fn take_work_location(&mut self) -> Vec<WorkLocationProperty>;
428	/// Get <https://schema.org/worksFor> from [`Self`] as borrowed slice.
429	fn get_works_for(&self) -> &[WorksForProperty];
430	/// Take <https://schema.org/worksFor> from [`Self`] as owned vector.
431	fn take_works_for(&mut self) -> Vec<WorksForProperty>;
432}
433impl PersonTrait for Person {
434	fn get_additional_name(&self) -> &[AdditionalNameProperty] {
435		self.r#additional_name.as_slice()
436	}
437	fn take_additional_name(&mut self) -> Vec<AdditionalNameProperty> {
438		std::mem::take(&mut self.r#additional_name)
439	}
440	fn get_address(&self) -> &[AddressProperty] {
441		self.r#address.as_slice()
442	}
443	fn take_address(&mut self) -> Vec<AddressProperty> {
444		std::mem::take(&mut self.r#address)
445	}
446	fn get_affiliation(&self) -> &[AffiliationProperty] {
447		self.r#affiliation.as_slice()
448	}
449	fn take_affiliation(&mut self) -> Vec<AffiliationProperty> {
450		std::mem::take(&mut self.r#affiliation)
451	}
452	fn get_agent_interaction_statistic(&self) -> &[AgentInteractionStatisticProperty] {
453		self.r#agent_interaction_statistic.as_slice()
454	}
455	fn take_agent_interaction_statistic(&mut self) -> Vec<AgentInteractionStatisticProperty> {
456		std::mem::take(&mut self.r#agent_interaction_statistic)
457	}
458	fn get_alumni_of(&self) -> &[AlumniOfProperty] {
459		self.r#alumni_of.as_slice()
460	}
461	fn take_alumni_of(&mut self) -> Vec<AlumniOfProperty> {
462		std::mem::take(&mut self.r#alumni_of)
463	}
464	fn get_award(&self) -> &[AwardProperty] {
465		self.r#award.as_slice()
466	}
467	fn take_award(&mut self) -> Vec<AwardProperty> {
468		std::mem::take(&mut self.r#award)
469	}
470	fn get_awards(&self) -> &[AwardsProperty] {
471		self.r#awards.as_slice()
472	}
473	fn take_awards(&mut self) -> Vec<AwardsProperty> {
474		std::mem::take(&mut self.r#awards)
475	}
476	fn get_birth_date(&self) -> &[BirthDateProperty] {
477		self.r#birth_date.as_slice()
478	}
479	fn take_birth_date(&mut self) -> Vec<BirthDateProperty> {
480		std::mem::take(&mut self.r#birth_date)
481	}
482	fn get_birth_place(&self) -> &[BirthPlaceProperty] {
483		self.r#birth_place.as_slice()
484	}
485	fn take_birth_place(&mut self) -> Vec<BirthPlaceProperty> {
486		std::mem::take(&mut self.r#birth_place)
487	}
488	fn get_brand(&self) -> &[BrandProperty] {
489		self.r#brand.as_slice()
490	}
491	fn take_brand(&mut self) -> Vec<BrandProperty> {
492		std::mem::take(&mut self.r#brand)
493	}
494	fn get_call_sign(&self) -> &[CallSignProperty] {
495		self.r#call_sign.as_slice()
496	}
497	fn take_call_sign(&mut self) -> Vec<CallSignProperty> {
498		std::mem::take(&mut self.r#call_sign)
499	}
500	fn get_children(&self) -> &[ChildrenProperty] {
501		self.r#children.as_slice()
502	}
503	fn take_children(&mut self) -> Vec<ChildrenProperty> {
504		std::mem::take(&mut self.r#children)
505	}
506	fn get_colleague(&self) -> &[ColleagueProperty] {
507		self.r#colleague.as_slice()
508	}
509	fn take_colleague(&mut self) -> Vec<ColleagueProperty> {
510		std::mem::take(&mut self.r#colleague)
511	}
512	fn get_colleagues(&self) -> &[ColleaguesProperty] {
513		self.r#colleagues.as_slice()
514	}
515	fn take_colleagues(&mut self) -> Vec<ColleaguesProperty> {
516		std::mem::take(&mut self.r#colleagues)
517	}
518	fn get_contact_point(&self) -> &[ContactPointProperty] {
519		self.r#contact_point.as_slice()
520	}
521	fn take_contact_point(&mut self) -> Vec<ContactPointProperty> {
522		std::mem::take(&mut self.r#contact_point)
523	}
524	fn get_contact_points(&self) -> &[ContactPointsProperty] {
525		self.r#contact_points.as_slice()
526	}
527	fn take_contact_points(&mut self) -> Vec<ContactPointsProperty> {
528		std::mem::take(&mut self.r#contact_points)
529	}
530	fn get_death_date(&self) -> &[DeathDateProperty] {
531		self.r#death_date.as_slice()
532	}
533	fn take_death_date(&mut self) -> Vec<DeathDateProperty> {
534		std::mem::take(&mut self.r#death_date)
535	}
536	fn get_death_place(&self) -> &[DeathPlaceProperty] {
537		self.r#death_place.as_slice()
538	}
539	fn take_death_place(&mut self) -> Vec<DeathPlaceProperty> {
540		std::mem::take(&mut self.r#death_place)
541	}
542	fn get_duns(&self) -> &[DunsProperty] {
543		self.r#duns.as_slice()
544	}
545	fn take_duns(&mut self) -> Vec<DunsProperty> {
546		std::mem::take(&mut self.r#duns)
547	}
548	fn get_email(&self) -> &[EmailProperty] {
549		self.r#email.as_slice()
550	}
551	fn take_email(&mut self) -> Vec<EmailProperty> {
552		std::mem::take(&mut self.r#email)
553	}
554	fn get_family_name(&self) -> &[FamilyNameProperty] {
555		self.r#family_name.as_slice()
556	}
557	fn take_family_name(&mut self) -> Vec<FamilyNameProperty> {
558		std::mem::take(&mut self.r#family_name)
559	}
560	fn get_fax_number(&self) -> &[FaxNumberProperty] {
561		self.r#fax_number.as_slice()
562	}
563	fn take_fax_number(&mut self) -> Vec<FaxNumberProperty> {
564		std::mem::take(&mut self.r#fax_number)
565	}
566	fn get_follows(&self) -> &[FollowsProperty] {
567		self.r#follows.as_slice()
568	}
569	fn take_follows(&mut self) -> Vec<FollowsProperty> {
570		std::mem::take(&mut self.r#follows)
571	}
572	fn get_funder(&self) -> &[FunderProperty] {
573		self.r#funder.as_slice()
574	}
575	fn take_funder(&mut self) -> Vec<FunderProperty> {
576		std::mem::take(&mut self.r#funder)
577	}
578	fn get_funding(&self) -> &[FundingProperty] {
579		self.r#funding.as_slice()
580	}
581	fn take_funding(&mut self) -> Vec<FundingProperty> {
582		std::mem::take(&mut self.r#funding)
583	}
584	fn get_gender(&self) -> &[GenderProperty] {
585		self.r#gender.as_slice()
586	}
587	fn take_gender(&mut self) -> Vec<GenderProperty> {
588		std::mem::take(&mut self.r#gender)
589	}
590	fn get_given_name(&self) -> &[GivenNameProperty] {
591		self.r#given_name.as_slice()
592	}
593	fn take_given_name(&mut self) -> Vec<GivenNameProperty> {
594		std::mem::take(&mut self.r#given_name)
595	}
596	fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty] {
597		self.r#global_location_number.as_slice()
598	}
599	fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty> {
600		std::mem::take(&mut self.r#global_location_number)
601	}
602	fn get_has_credential(&self) -> &[HasCredentialProperty] {
603		self.r#has_credential.as_slice()
604	}
605	fn take_has_credential(&mut self) -> Vec<HasCredentialProperty> {
606		std::mem::take(&mut self.r#has_credential)
607	}
608	fn get_has_occupation(&self) -> &[HasOccupationProperty] {
609		self.r#has_occupation.as_slice()
610	}
611	fn take_has_occupation(&mut self) -> Vec<HasOccupationProperty> {
612		std::mem::take(&mut self.r#has_occupation)
613	}
614	fn get_has_offer_catalog(&self) -> &[HasOfferCatalogProperty] {
615		self.r#has_offer_catalog.as_slice()
616	}
617	fn take_has_offer_catalog(&mut self) -> Vec<HasOfferCatalogProperty> {
618		std::mem::take(&mut self.r#has_offer_catalog)
619	}
620	fn get_has_pos(&self) -> &[HasPosProperty] {
621		self.r#has_pos.as_slice()
622	}
623	fn take_has_pos(&mut self) -> Vec<HasPosProperty> {
624		std::mem::take(&mut self.r#has_pos)
625	}
626	fn get_height(&self) -> &[HeightProperty] {
627		self.r#height.as_slice()
628	}
629	fn take_height(&mut self) -> Vec<HeightProperty> {
630		std::mem::take(&mut self.r#height)
631	}
632	fn get_home_location(&self) -> &[HomeLocationProperty] {
633		self.r#home_location.as_slice()
634	}
635	fn take_home_location(&mut self) -> Vec<HomeLocationProperty> {
636		std::mem::take(&mut self.r#home_location)
637	}
638	fn get_honorific_prefix(&self) -> &[HonorificPrefixProperty] {
639		self.r#honorific_prefix.as_slice()
640	}
641	fn take_honorific_prefix(&mut self) -> Vec<HonorificPrefixProperty> {
642		std::mem::take(&mut self.r#honorific_prefix)
643	}
644	fn get_honorific_suffix(&self) -> &[HonorificSuffixProperty] {
645		self.r#honorific_suffix.as_slice()
646	}
647	fn take_honorific_suffix(&mut self) -> Vec<HonorificSuffixProperty> {
648		std::mem::take(&mut self.r#honorific_suffix)
649	}
650	fn get_interaction_statistic(&self) -> &[InteractionStatisticProperty] {
651		self.r#interaction_statistic.as_slice()
652	}
653	fn take_interaction_statistic(&mut self) -> Vec<InteractionStatisticProperty> {
654		std::mem::take(&mut self.r#interaction_statistic)
655	}
656	fn get_isic_v_4(&self) -> &[IsicV4Property] {
657		self.r#isic_v_4.as_slice()
658	}
659	fn take_isic_v_4(&mut self) -> Vec<IsicV4Property> {
660		std::mem::take(&mut self.r#isic_v_4)
661	}
662	fn get_job_title(&self) -> &[JobTitleProperty] {
663		self.r#job_title.as_slice()
664	}
665	fn take_job_title(&mut self) -> Vec<JobTitleProperty> {
666		std::mem::take(&mut self.r#job_title)
667	}
668	fn get_knows(&self) -> &[KnowsProperty] {
669		self.r#knows.as_slice()
670	}
671	fn take_knows(&mut self) -> Vec<KnowsProperty> {
672		std::mem::take(&mut self.r#knows)
673	}
674	fn get_knows_about(&self) -> &[KnowsAboutProperty] {
675		self.r#knows_about.as_slice()
676	}
677	fn take_knows_about(&mut self) -> Vec<KnowsAboutProperty> {
678		std::mem::take(&mut self.r#knows_about)
679	}
680	fn get_knows_language(&self) -> &[KnowsLanguageProperty] {
681		self.r#knows_language.as_slice()
682	}
683	fn take_knows_language(&mut self) -> Vec<KnowsLanguageProperty> {
684		std::mem::take(&mut self.r#knows_language)
685	}
686	fn get_makes_offer(&self) -> &[MakesOfferProperty] {
687		self.r#makes_offer.as_slice()
688	}
689	fn take_makes_offer(&mut self) -> Vec<MakesOfferProperty> {
690		std::mem::take(&mut self.r#makes_offer)
691	}
692	fn get_member_of(&self) -> &[MemberOfProperty] {
693		self.r#member_of.as_slice()
694	}
695	fn take_member_of(&mut self) -> Vec<MemberOfProperty> {
696		std::mem::take(&mut self.r#member_of)
697	}
698	fn get_naics(&self) -> &[NaicsProperty] {
699		self.r#naics.as_slice()
700	}
701	fn take_naics(&mut self) -> Vec<NaicsProperty> {
702		std::mem::take(&mut self.r#naics)
703	}
704	fn get_nationality(&self) -> &[NationalityProperty] {
705		self.r#nationality.as_slice()
706	}
707	fn take_nationality(&mut self) -> Vec<NationalityProperty> {
708		std::mem::take(&mut self.r#nationality)
709	}
710	fn get_net_worth(&self) -> &[NetWorthProperty] {
711		self.r#net_worth.as_slice()
712	}
713	fn take_net_worth(&mut self) -> Vec<NetWorthProperty> {
714		std::mem::take(&mut self.r#net_worth)
715	}
716	fn get_owns(&self) -> &[OwnsProperty] {
717		self.r#owns.as_slice()
718	}
719	fn take_owns(&mut self) -> Vec<OwnsProperty> {
720		std::mem::take(&mut self.r#owns)
721	}
722	fn get_parent(&self) -> &[ParentProperty] {
723		self.r#parent.as_slice()
724	}
725	fn take_parent(&mut self) -> Vec<ParentProperty> {
726		std::mem::take(&mut self.r#parent)
727	}
728	fn get_parents(&self) -> &[ParentsProperty] {
729		self.r#parents.as_slice()
730	}
731	fn take_parents(&mut self) -> Vec<ParentsProperty> {
732		std::mem::take(&mut self.r#parents)
733	}
734	fn get_performer_in(&self) -> &[PerformerInProperty] {
735		self.r#performer_in.as_slice()
736	}
737	fn take_performer_in(&mut self) -> Vec<PerformerInProperty> {
738		std::mem::take(&mut self.r#performer_in)
739	}
740	fn get_publishing_principles(&self) -> &[PublishingPrinciplesProperty] {
741		self.r#publishing_principles.as_slice()
742	}
743	fn take_publishing_principles(&mut self) -> Vec<PublishingPrinciplesProperty> {
744		std::mem::take(&mut self.r#publishing_principles)
745	}
746	fn get_related_to(&self) -> &[RelatedToProperty] {
747		self.r#related_to.as_slice()
748	}
749	fn take_related_to(&mut self) -> Vec<RelatedToProperty> {
750		std::mem::take(&mut self.r#related_to)
751	}
752	fn get_seeks(&self) -> &[SeeksProperty] {
753		self.r#seeks.as_slice()
754	}
755	fn take_seeks(&mut self) -> Vec<SeeksProperty> {
756		std::mem::take(&mut self.r#seeks)
757	}
758	fn get_sibling(&self) -> &[SiblingProperty] {
759		self.r#sibling.as_slice()
760	}
761	fn take_sibling(&mut self) -> Vec<SiblingProperty> {
762		std::mem::take(&mut self.r#sibling)
763	}
764	fn get_siblings(&self) -> &[SiblingsProperty] {
765		self.r#siblings.as_slice()
766	}
767	fn take_siblings(&mut self) -> Vec<SiblingsProperty> {
768		std::mem::take(&mut self.r#siblings)
769	}
770	fn get_sponsor(&self) -> &[SponsorProperty] {
771		self.r#sponsor.as_slice()
772	}
773	fn take_sponsor(&mut self) -> Vec<SponsorProperty> {
774		std::mem::take(&mut self.r#sponsor)
775	}
776	fn get_spouse(&self) -> &[SpouseProperty] {
777		self.r#spouse.as_slice()
778	}
779	fn take_spouse(&mut self) -> Vec<SpouseProperty> {
780		std::mem::take(&mut self.r#spouse)
781	}
782	fn get_tax_id(&self) -> &[TaxIdProperty] {
783		self.r#tax_id.as_slice()
784	}
785	fn take_tax_id(&mut self) -> Vec<TaxIdProperty> {
786		std::mem::take(&mut self.r#tax_id)
787	}
788	fn get_telephone(&self) -> &[TelephoneProperty] {
789		self.r#telephone.as_slice()
790	}
791	fn take_telephone(&mut self) -> Vec<TelephoneProperty> {
792		std::mem::take(&mut self.r#telephone)
793	}
794	fn get_vat_id(&self) -> &[VatIdProperty] {
795		self.r#vat_id.as_slice()
796	}
797	fn take_vat_id(&mut self) -> Vec<VatIdProperty> {
798		std::mem::take(&mut self.r#vat_id)
799	}
800	fn get_weight(&self) -> &[WeightProperty] {
801		self.r#weight.as_slice()
802	}
803	fn take_weight(&mut self) -> Vec<WeightProperty> {
804		std::mem::take(&mut self.r#weight)
805	}
806	fn get_work_location(&self) -> &[WorkLocationProperty] {
807		self.r#work_location.as_slice()
808	}
809	fn take_work_location(&mut self) -> Vec<WorkLocationProperty> {
810		std::mem::take(&mut self.r#work_location)
811	}
812	fn get_works_for(&self) -> &[WorksForProperty] {
813		self.r#works_for.as_slice()
814	}
815	fn take_works_for(&mut self) -> Vec<WorksForProperty> {
816		std::mem::take(&mut self.r#works_for)
817	}
818}
819impl ThingTrait for Person {
820	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
821		self.r#additional_type.as_slice()
822	}
823	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
824		std::mem::take(&mut self.r#additional_type)
825	}
826	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
827		self.r#alternate_name.as_slice()
828	}
829	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
830		std::mem::take(&mut self.r#alternate_name)
831	}
832	fn get_description(&self) -> &[DescriptionProperty] {
833		self.r#description.as_slice()
834	}
835	fn take_description(&mut self) -> Vec<DescriptionProperty> {
836		std::mem::take(&mut self.r#description)
837	}
838	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
839		self.r#disambiguating_description.as_slice()
840	}
841	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
842		std::mem::take(&mut self.r#disambiguating_description)
843	}
844	fn get_identifier(&self) -> &[IdentifierProperty] {
845		self.r#identifier.as_slice()
846	}
847	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
848		std::mem::take(&mut self.r#identifier)
849	}
850	fn get_image(&self) -> &[ImageProperty] {
851		self.r#image.as_slice()
852	}
853	fn take_image(&mut self) -> Vec<ImageProperty> {
854		std::mem::take(&mut self.r#image)
855	}
856	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
857		self.r#main_entity_of_page.as_slice()
858	}
859	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
860		std::mem::take(&mut self.r#main_entity_of_page)
861	}
862	fn get_name(&self) -> &[NameProperty] {
863		self.r#name.as_slice()
864	}
865	fn take_name(&mut self) -> Vec<NameProperty> {
866		std::mem::take(&mut self.r#name)
867	}
868	fn get_potential_action(&self) -> &[PotentialActionProperty] {
869		self.r#potential_action.as_slice()
870	}
871	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
872		std::mem::take(&mut self.r#potential_action)
873	}
874	fn get_same_as(&self) -> &[SameAsProperty] {
875		self.r#same_as.as_slice()
876	}
877	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
878		std::mem::take(&mut self.r#same_as)
879	}
880	fn get_subject_of(&self) -> &[SubjectOfProperty] {
881		self.r#subject_of.as_slice()
882	}
883	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
884		std::mem::take(&mut self.r#subject_of)
885	}
886	fn get_url(&self) -> &[UrlProperty] {
887		self.r#url.as_slice()
888	}
889	fn take_url(&mut self) -> Vec<UrlProperty> {
890		std::mem::take(&mut self.r#url)
891	}
892}
893#[cfg(feature = "serde")]
894mod serde {
895	use std::{fmt, fmt::Formatter};
896
897	use ::serde::{
898		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
899	};
900
901	use super::*;
902	impl Serialize for Person {
903		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
904		where
905			S: Serializer,
906		{
907			let len: usize = [
908				!Vec::is_empty(&self.r#additional_name) as usize,
909				!Vec::is_empty(&self.r#address) as usize,
910				!Vec::is_empty(&self.r#affiliation) as usize,
911				!Vec::is_empty(&self.r#agent_interaction_statistic) as usize,
912				!Vec::is_empty(&self.r#alumni_of) as usize,
913				!Vec::is_empty(&self.r#award) as usize,
914				!Vec::is_empty(&self.r#awards) as usize,
915				!Vec::is_empty(&self.r#birth_date) as usize,
916				!Vec::is_empty(&self.r#birth_place) as usize,
917				!Vec::is_empty(&self.r#brand) as usize,
918				!Vec::is_empty(&self.r#call_sign) as usize,
919				!Vec::is_empty(&self.r#children) as usize,
920				!Vec::is_empty(&self.r#colleague) as usize,
921				!Vec::is_empty(&self.r#colleagues) as usize,
922				!Vec::is_empty(&self.r#contact_point) as usize,
923				!Vec::is_empty(&self.r#contact_points) as usize,
924				!Vec::is_empty(&self.r#death_date) as usize,
925				!Vec::is_empty(&self.r#death_place) as usize,
926				!Vec::is_empty(&self.r#duns) as usize,
927				!Vec::is_empty(&self.r#email) as usize,
928				!Vec::is_empty(&self.r#family_name) as usize,
929				!Vec::is_empty(&self.r#fax_number) as usize,
930				!Vec::is_empty(&self.r#follows) as usize,
931				!Vec::is_empty(&self.r#funder) as usize,
932				!Vec::is_empty(&self.r#funding) as usize,
933				!Vec::is_empty(&self.r#gender) as usize,
934				!Vec::is_empty(&self.r#given_name) as usize,
935				!Vec::is_empty(&self.r#global_location_number) as usize,
936				!Vec::is_empty(&self.r#has_credential) as usize,
937				!Vec::is_empty(&self.r#has_occupation) as usize,
938				!Vec::is_empty(&self.r#has_offer_catalog) as usize,
939				!Vec::is_empty(&self.r#has_pos) as usize,
940				!Vec::is_empty(&self.r#height) as usize,
941				!Vec::is_empty(&self.r#home_location) as usize,
942				!Vec::is_empty(&self.r#honorific_prefix) as usize,
943				!Vec::is_empty(&self.r#honorific_suffix) as usize,
944				!Vec::is_empty(&self.r#interaction_statistic) as usize,
945				!Vec::is_empty(&self.r#isic_v_4) as usize,
946				!Vec::is_empty(&self.r#job_title) as usize,
947				!Vec::is_empty(&self.r#knows) as usize,
948				!Vec::is_empty(&self.r#knows_about) as usize,
949				!Vec::is_empty(&self.r#knows_language) as usize,
950				!Vec::is_empty(&self.r#makes_offer) as usize,
951				!Vec::is_empty(&self.r#member_of) as usize,
952				!Vec::is_empty(&self.r#naics) as usize,
953				!Vec::is_empty(&self.r#nationality) as usize,
954				!Vec::is_empty(&self.r#net_worth) as usize,
955				!Vec::is_empty(&self.r#owns) as usize,
956				!Vec::is_empty(&self.r#parent) as usize,
957				!Vec::is_empty(&self.r#parents) as usize,
958				!Vec::is_empty(&self.r#performer_in) as usize,
959				!Vec::is_empty(&self.r#publishing_principles) as usize,
960				!Vec::is_empty(&self.r#related_to) as usize,
961				!Vec::is_empty(&self.r#seeks) as usize,
962				!Vec::is_empty(&self.r#sibling) as usize,
963				!Vec::is_empty(&self.r#siblings) as usize,
964				!Vec::is_empty(&self.r#sponsor) as usize,
965				!Vec::is_empty(&self.r#spouse) as usize,
966				!Vec::is_empty(&self.r#tax_id) as usize,
967				!Vec::is_empty(&self.r#telephone) as usize,
968				!Vec::is_empty(&self.r#vat_id) as usize,
969				!Vec::is_empty(&self.r#weight) as usize,
970				!Vec::is_empty(&self.r#work_location) as usize,
971				!Vec::is_empty(&self.r#works_for) as usize,
972				!Vec::is_empty(&self.r#additional_type) as usize,
973				!Vec::is_empty(&self.r#alternate_name) as usize,
974				!Vec::is_empty(&self.r#description) as usize,
975				!Vec::is_empty(&self.r#disambiguating_description) as usize,
976				!Vec::is_empty(&self.r#identifier) as usize,
977				!Vec::is_empty(&self.r#image) as usize,
978				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
979				!Vec::is_empty(&self.r#name) as usize,
980				!Vec::is_empty(&self.r#potential_action) as usize,
981				!Vec::is_empty(&self.r#same_as) as usize,
982				!Vec::is_empty(&self.r#subject_of) as usize,
983				!Vec::is_empty(&self.r#url) as usize,
984			]
985			.iter()
986			.sum();
987			let mut serialize_struct = Serializer::serialize_struct(serializer, "Person", len)?;
988			if !Vec::is_empty(&self.r#additional_name) {
989				serialize_struct.serialize_field("additionalName", {
990					struct SerializeWith<'a>(&'a Vec<AdditionalNameProperty>);
991					impl<'a> Serialize for SerializeWith<'a> {
992						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
993						where
994							S: Serializer,
995						{
996							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
997								self.0, serializer,
998							)
999						}
1000					}
1001					&SerializeWith(&self.r#additional_name)
1002				})?;
1003			} else {
1004				serialize_struct.skip_field("additionalName")?;
1005			}
1006			if !Vec::is_empty(&self.r#address) {
1007				serialize_struct.serialize_field("address", {
1008					struct SerializeWith<'a>(&'a Vec<AddressProperty>);
1009					impl<'a> Serialize for SerializeWith<'a> {
1010						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1011						where
1012							S: Serializer,
1013						{
1014							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1015								self.0, serializer,
1016							)
1017						}
1018					}
1019					&SerializeWith(&self.r#address)
1020				})?;
1021			} else {
1022				serialize_struct.skip_field("address")?;
1023			}
1024			if !Vec::is_empty(&self.r#affiliation) {
1025				serialize_struct.serialize_field("affiliation", {
1026					struct SerializeWith<'a>(&'a Vec<AffiliationProperty>);
1027					impl<'a> Serialize for SerializeWith<'a> {
1028						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1029						where
1030							S: Serializer,
1031						{
1032							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1033								self.0, serializer,
1034							)
1035						}
1036					}
1037					&SerializeWith(&self.r#affiliation)
1038				})?;
1039			} else {
1040				serialize_struct.skip_field("affiliation")?;
1041			}
1042			if !Vec::is_empty(&self.r#agent_interaction_statistic) {
1043				serialize_struct.serialize_field("agentInteractionStatistic", {
1044					struct SerializeWith<'a>(&'a Vec<AgentInteractionStatisticProperty>);
1045					impl<'a> Serialize for SerializeWith<'a> {
1046						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1047						where
1048							S: Serializer,
1049						{
1050							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1051								self.0, serializer,
1052							)
1053						}
1054					}
1055					&SerializeWith(&self.r#agent_interaction_statistic)
1056				})?;
1057			} else {
1058				serialize_struct.skip_field("agentInteractionStatistic")?;
1059			}
1060			if !Vec::is_empty(&self.r#alumni_of) {
1061				serialize_struct.serialize_field("alumniOf", {
1062					struct SerializeWith<'a>(&'a Vec<AlumniOfProperty>);
1063					impl<'a> Serialize for SerializeWith<'a> {
1064						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1065						where
1066							S: Serializer,
1067						{
1068							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1069								self.0, serializer,
1070							)
1071						}
1072					}
1073					&SerializeWith(&self.r#alumni_of)
1074				})?;
1075			} else {
1076				serialize_struct.skip_field("alumniOf")?;
1077			}
1078			if !Vec::is_empty(&self.r#award) {
1079				serialize_struct.serialize_field("award", {
1080					struct SerializeWith<'a>(&'a Vec<AwardProperty>);
1081					impl<'a> Serialize for SerializeWith<'a> {
1082						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1083						where
1084							S: Serializer,
1085						{
1086							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1087								self.0, serializer,
1088							)
1089						}
1090					}
1091					&SerializeWith(&self.r#award)
1092				})?;
1093			} else {
1094				serialize_struct.skip_field("award")?;
1095			}
1096			if !Vec::is_empty(&self.r#awards) {
1097				serialize_struct.serialize_field("awards", {
1098					struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
1099					impl<'a> Serialize for SerializeWith<'a> {
1100						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1101						where
1102							S: Serializer,
1103						{
1104							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1105								self.0, serializer,
1106							)
1107						}
1108					}
1109					&SerializeWith(&self.r#awards)
1110				})?;
1111			} else {
1112				serialize_struct.skip_field("awards")?;
1113			}
1114			if !Vec::is_empty(&self.r#birth_date) {
1115				serialize_struct.serialize_field("birthDate", {
1116					struct SerializeWith<'a>(&'a Vec<BirthDateProperty>);
1117					impl<'a> Serialize for SerializeWith<'a> {
1118						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1119						where
1120							S: Serializer,
1121						{
1122							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1123								self.0, serializer,
1124							)
1125						}
1126					}
1127					&SerializeWith(&self.r#birth_date)
1128				})?;
1129			} else {
1130				serialize_struct.skip_field("birthDate")?;
1131			}
1132			if !Vec::is_empty(&self.r#birth_place) {
1133				serialize_struct.serialize_field("birthPlace", {
1134					struct SerializeWith<'a>(&'a Vec<BirthPlaceProperty>);
1135					impl<'a> Serialize for SerializeWith<'a> {
1136						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1137						where
1138							S: Serializer,
1139						{
1140							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1141								self.0, serializer,
1142							)
1143						}
1144					}
1145					&SerializeWith(&self.r#birth_place)
1146				})?;
1147			} else {
1148				serialize_struct.skip_field("birthPlace")?;
1149			}
1150			if !Vec::is_empty(&self.r#brand) {
1151				serialize_struct.serialize_field("brand", {
1152					struct SerializeWith<'a>(&'a Vec<BrandProperty>);
1153					impl<'a> Serialize for SerializeWith<'a> {
1154						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1155						where
1156							S: Serializer,
1157						{
1158							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1159								self.0, serializer,
1160							)
1161						}
1162					}
1163					&SerializeWith(&self.r#brand)
1164				})?;
1165			} else {
1166				serialize_struct.skip_field("brand")?;
1167			}
1168			if !Vec::is_empty(&self.r#call_sign) {
1169				serialize_struct.serialize_field("callSign", {
1170					struct SerializeWith<'a>(&'a Vec<CallSignProperty>);
1171					impl<'a> Serialize for SerializeWith<'a> {
1172						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1173						where
1174							S: Serializer,
1175						{
1176							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1177								self.0, serializer,
1178							)
1179						}
1180					}
1181					&SerializeWith(&self.r#call_sign)
1182				})?;
1183			} else {
1184				serialize_struct.skip_field("callSign")?;
1185			}
1186			if !Vec::is_empty(&self.r#children) {
1187				serialize_struct.serialize_field("children", {
1188					struct SerializeWith<'a>(&'a Vec<ChildrenProperty>);
1189					impl<'a> Serialize for SerializeWith<'a> {
1190						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1191						where
1192							S: Serializer,
1193						{
1194							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1195								self.0, serializer,
1196							)
1197						}
1198					}
1199					&SerializeWith(&self.r#children)
1200				})?;
1201			} else {
1202				serialize_struct.skip_field("children")?;
1203			}
1204			if !Vec::is_empty(&self.r#colleague) {
1205				serialize_struct.serialize_field("colleague", {
1206					struct SerializeWith<'a>(&'a Vec<ColleagueProperty>);
1207					impl<'a> Serialize for SerializeWith<'a> {
1208						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1209						where
1210							S: Serializer,
1211						{
1212							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1213								self.0, serializer,
1214							)
1215						}
1216					}
1217					&SerializeWith(&self.r#colleague)
1218				})?;
1219			} else {
1220				serialize_struct.skip_field("colleague")?;
1221			}
1222			if !Vec::is_empty(&self.r#colleagues) {
1223				serialize_struct.serialize_field("colleagues", {
1224					struct SerializeWith<'a>(&'a Vec<ColleaguesProperty>);
1225					impl<'a> Serialize for SerializeWith<'a> {
1226						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1227						where
1228							S: Serializer,
1229						{
1230							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1231								self.0, serializer,
1232							)
1233						}
1234					}
1235					&SerializeWith(&self.r#colleagues)
1236				})?;
1237			} else {
1238				serialize_struct.skip_field("colleagues")?;
1239			}
1240			if !Vec::is_empty(&self.r#contact_point) {
1241				serialize_struct.serialize_field("contactPoint", {
1242					struct SerializeWith<'a>(&'a Vec<ContactPointProperty>);
1243					impl<'a> Serialize for SerializeWith<'a> {
1244						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1245						where
1246							S: Serializer,
1247						{
1248							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1249								self.0, serializer,
1250							)
1251						}
1252					}
1253					&SerializeWith(&self.r#contact_point)
1254				})?;
1255			} else {
1256				serialize_struct.skip_field("contactPoint")?;
1257			}
1258			if !Vec::is_empty(&self.r#contact_points) {
1259				serialize_struct.serialize_field("contactPoints", {
1260					struct SerializeWith<'a>(&'a Vec<ContactPointsProperty>);
1261					impl<'a> Serialize for SerializeWith<'a> {
1262						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1263						where
1264							S: Serializer,
1265						{
1266							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1267								self.0, serializer,
1268							)
1269						}
1270					}
1271					&SerializeWith(&self.r#contact_points)
1272				})?;
1273			} else {
1274				serialize_struct.skip_field("contactPoints")?;
1275			}
1276			if !Vec::is_empty(&self.r#death_date) {
1277				serialize_struct.serialize_field("deathDate", {
1278					struct SerializeWith<'a>(&'a Vec<DeathDateProperty>);
1279					impl<'a> Serialize for SerializeWith<'a> {
1280						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1281						where
1282							S: Serializer,
1283						{
1284							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1285								self.0, serializer,
1286							)
1287						}
1288					}
1289					&SerializeWith(&self.r#death_date)
1290				})?;
1291			} else {
1292				serialize_struct.skip_field("deathDate")?;
1293			}
1294			if !Vec::is_empty(&self.r#death_place) {
1295				serialize_struct.serialize_field("deathPlace", {
1296					struct SerializeWith<'a>(&'a Vec<DeathPlaceProperty>);
1297					impl<'a> Serialize for SerializeWith<'a> {
1298						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1299						where
1300							S: Serializer,
1301						{
1302							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1303								self.0, serializer,
1304							)
1305						}
1306					}
1307					&SerializeWith(&self.r#death_place)
1308				})?;
1309			} else {
1310				serialize_struct.skip_field("deathPlace")?;
1311			}
1312			if !Vec::is_empty(&self.r#duns) {
1313				serialize_struct.serialize_field("duns", {
1314					struct SerializeWith<'a>(&'a Vec<DunsProperty>);
1315					impl<'a> Serialize for SerializeWith<'a> {
1316						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1317						where
1318							S: Serializer,
1319						{
1320							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1321								self.0, serializer,
1322							)
1323						}
1324					}
1325					&SerializeWith(&self.r#duns)
1326				})?;
1327			} else {
1328				serialize_struct.skip_field("duns")?;
1329			}
1330			if !Vec::is_empty(&self.r#email) {
1331				serialize_struct.serialize_field("email", {
1332					struct SerializeWith<'a>(&'a Vec<EmailProperty>);
1333					impl<'a> Serialize for SerializeWith<'a> {
1334						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1335						where
1336							S: Serializer,
1337						{
1338							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1339								self.0, serializer,
1340							)
1341						}
1342					}
1343					&SerializeWith(&self.r#email)
1344				})?;
1345			} else {
1346				serialize_struct.skip_field("email")?;
1347			}
1348			if !Vec::is_empty(&self.r#family_name) {
1349				serialize_struct.serialize_field("familyName", {
1350					struct SerializeWith<'a>(&'a Vec<FamilyNameProperty>);
1351					impl<'a> Serialize for SerializeWith<'a> {
1352						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1353						where
1354							S: Serializer,
1355						{
1356							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1357								self.0, serializer,
1358							)
1359						}
1360					}
1361					&SerializeWith(&self.r#family_name)
1362				})?;
1363			} else {
1364				serialize_struct.skip_field("familyName")?;
1365			}
1366			if !Vec::is_empty(&self.r#fax_number) {
1367				serialize_struct.serialize_field("faxNumber", {
1368					struct SerializeWith<'a>(&'a Vec<FaxNumberProperty>);
1369					impl<'a> Serialize for SerializeWith<'a> {
1370						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1371						where
1372							S: Serializer,
1373						{
1374							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1375								self.0, serializer,
1376							)
1377						}
1378					}
1379					&SerializeWith(&self.r#fax_number)
1380				})?;
1381			} else {
1382				serialize_struct.skip_field("faxNumber")?;
1383			}
1384			if !Vec::is_empty(&self.r#follows) {
1385				serialize_struct.serialize_field("follows", {
1386					struct SerializeWith<'a>(&'a Vec<FollowsProperty>);
1387					impl<'a> Serialize for SerializeWith<'a> {
1388						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1389						where
1390							S: Serializer,
1391						{
1392							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1393								self.0, serializer,
1394							)
1395						}
1396					}
1397					&SerializeWith(&self.r#follows)
1398				})?;
1399			} else {
1400				serialize_struct.skip_field("follows")?;
1401			}
1402			if !Vec::is_empty(&self.r#funder) {
1403				serialize_struct.serialize_field("funder", {
1404					struct SerializeWith<'a>(&'a Vec<FunderProperty>);
1405					impl<'a> Serialize for SerializeWith<'a> {
1406						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1407						where
1408							S: Serializer,
1409						{
1410							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1411								self.0, serializer,
1412							)
1413						}
1414					}
1415					&SerializeWith(&self.r#funder)
1416				})?;
1417			} else {
1418				serialize_struct.skip_field("funder")?;
1419			}
1420			if !Vec::is_empty(&self.r#funding) {
1421				serialize_struct.serialize_field("funding", {
1422					struct SerializeWith<'a>(&'a Vec<FundingProperty>);
1423					impl<'a> Serialize for SerializeWith<'a> {
1424						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1425						where
1426							S: Serializer,
1427						{
1428							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1429								self.0, serializer,
1430							)
1431						}
1432					}
1433					&SerializeWith(&self.r#funding)
1434				})?;
1435			} else {
1436				serialize_struct.skip_field("funding")?;
1437			}
1438			if !Vec::is_empty(&self.r#gender) {
1439				serialize_struct.serialize_field("gender", {
1440					struct SerializeWith<'a>(&'a Vec<GenderProperty>);
1441					impl<'a> Serialize for SerializeWith<'a> {
1442						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1443						where
1444							S: Serializer,
1445						{
1446							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1447								self.0, serializer,
1448							)
1449						}
1450					}
1451					&SerializeWith(&self.r#gender)
1452				})?;
1453			} else {
1454				serialize_struct.skip_field("gender")?;
1455			}
1456			if !Vec::is_empty(&self.r#given_name) {
1457				serialize_struct.serialize_field("givenName", {
1458					struct SerializeWith<'a>(&'a Vec<GivenNameProperty>);
1459					impl<'a> Serialize for SerializeWith<'a> {
1460						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1461						where
1462							S: Serializer,
1463						{
1464							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1465								self.0, serializer,
1466							)
1467						}
1468					}
1469					&SerializeWith(&self.r#given_name)
1470				})?;
1471			} else {
1472				serialize_struct.skip_field("givenName")?;
1473			}
1474			if !Vec::is_empty(&self.r#global_location_number) {
1475				serialize_struct.serialize_field("globalLocationNumber", {
1476					struct SerializeWith<'a>(&'a Vec<GlobalLocationNumberProperty>);
1477					impl<'a> Serialize for SerializeWith<'a> {
1478						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1479						where
1480							S: Serializer,
1481						{
1482							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1483								self.0, serializer,
1484							)
1485						}
1486					}
1487					&SerializeWith(&self.r#global_location_number)
1488				})?;
1489			} else {
1490				serialize_struct.skip_field("globalLocationNumber")?;
1491			}
1492			if !Vec::is_empty(&self.r#has_credential) {
1493				serialize_struct.serialize_field("hasCredential", {
1494					struct SerializeWith<'a>(&'a Vec<HasCredentialProperty>);
1495					impl<'a> Serialize for SerializeWith<'a> {
1496						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1497						where
1498							S: Serializer,
1499						{
1500							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1501								self.0, serializer,
1502							)
1503						}
1504					}
1505					&SerializeWith(&self.r#has_credential)
1506				})?;
1507			} else {
1508				serialize_struct.skip_field("hasCredential")?;
1509			}
1510			if !Vec::is_empty(&self.r#has_occupation) {
1511				serialize_struct.serialize_field("hasOccupation", {
1512					struct SerializeWith<'a>(&'a Vec<HasOccupationProperty>);
1513					impl<'a> Serialize for SerializeWith<'a> {
1514						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1515						where
1516							S: Serializer,
1517						{
1518							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1519								self.0, serializer,
1520							)
1521						}
1522					}
1523					&SerializeWith(&self.r#has_occupation)
1524				})?;
1525			} else {
1526				serialize_struct.skip_field("hasOccupation")?;
1527			}
1528			if !Vec::is_empty(&self.r#has_offer_catalog) {
1529				serialize_struct.serialize_field("hasOfferCatalog", {
1530					struct SerializeWith<'a>(&'a Vec<HasOfferCatalogProperty>);
1531					impl<'a> Serialize for SerializeWith<'a> {
1532						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1533						where
1534							S: Serializer,
1535						{
1536							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1537								self.0, serializer,
1538							)
1539						}
1540					}
1541					&SerializeWith(&self.r#has_offer_catalog)
1542				})?;
1543			} else {
1544				serialize_struct.skip_field("hasOfferCatalog")?;
1545			}
1546			if !Vec::is_empty(&self.r#has_pos) {
1547				serialize_struct.serialize_field("hasPOS", {
1548					struct SerializeWith<'a>(&'a Vec<HasPosProperty>);
1549					impl<'a> Serialize for SerializeWith<'a> {
1550						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1551						where
1552							S: Serializer,
1553						{
1554							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1555								self.0, serializer,
1556							)
1557						}
1558					}
1559					&SerializeWith(&self.r#has_pos)
1560				})?;
1561			} else {
1562				serialize_struct.skip_field("hasPOS")?;
1563			}
1564			if !Vec::is_empty(&self.r#height) {
1565				serialize_struct.serialize_field("height", {
1566					struct SerializeWith<'a>(&'a Vec<HeightProperty>);
1567					impl<'a> Serialize for SerializeWith<'a> {
1568						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1569						where
1570							S: Serializer,
1571						{
1572							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1573								self.0, serializer,
1574							)
1575						}
1576					}
1577					&SerializeWith(&self.r#height)
1578				})?;
1579			} else {
1580				serialize_struct.skip_field("height")?;
1581			}
1582			if !Vec::is_empty(&self.r#home_location) {
1583				serialize_struct.serialize_field("homeLocation", {
1584					struct SerializeWith<'a>(&'a Vec<HomeLocationProperty>);
1585					impl<'a> Serialize for SerializeWith<'a> {
1586						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1587						where
1588							S: Serializer,
1589						{
1590							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1591								self.0, serializer,
1592							)
1593						}
1594					}
1595					&SerializeWith(&self.r#home_location)
1596				})?;
1597			} else {
1598				serialize_struct.skip_field("homeLocation")?;
1599			}
1600			if !Vec::is_empty(&self.r#honorific_prefix) {
1601				serialize_struct.serialize_field("honorificPrefix", {
1602					struct SerializeWith<'a>(&'a Vec<HonorificPrefixProperty>);
1603					impl<'a> Serialize for SerializeWith<'a> {
1604						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1605						where
1606							S: Serializer,
1607						{
1608							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1609								self.0, serializer,
1610							)
1611						}
1612					}
1613					&SerializeWith(&self.r#honorific_prefix)
1614				})?;
1615			} else {
1616				serialize_struct.skip_field("honorificPrefix")?;
1617			}
1618			if !Vec::is_empty(&self.r#honorific_suffix) {
1619				serialize_struct.serialize_field("honorificSuffix", {
1620					struct SerializeWith<'a>(&'a Vec<HonorificSuffixProperty>);
1621					impl<'a> Serialize for SerializeWith<'a> {
1622						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1623						where
1624							S: Serializer,
1625						{
1626							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1627								self.0, serializer,
1628							)
1629						}
1630					}
1631					&SerializeWith(&self.r#honorific_suffix)
1632				})?;
1633			} else {
1634				serialize_struct.skip_field("honorificSuffix")?;
1635			}
1636			if !Vec::is_empty(&self.r#interaction_statistic) {
1637				serialize_struct.serialize_field("interactionStatistic", {
1638					struct SerializeWith<'a>(&'a Vec<InteractionStatisticProperty>);
1639					impl<'a> Serialize for SerializeWith<'a> {
1640						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1641						where
1642							S: Serializer,
1643						{
1644							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1645								self.0, serializer,
1646							)
1647						}
1648					}
1649					&SerializeWith(&self.r#interaction_statistic)
1650				})?;
1651			} else {
1652				serialize_struct.skip_field("interactionStatistic")?;
1653			}
1654			if !Vec::is_empty(&self.r#isic_v_4) {
1655				serialize_struct.serialize_field("isicV4", {
1656					struct SerializeWith<'a>(&'a Vec<IsicV4Property>);
1657					impl<'a> Serialize for SerializeWith<'a> {
1658						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1659						where
1660							S: Serializer,
1661						{
1662							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1663								self.0, serializer,
1664							)
1665						}
1666					}
1667					&SerializeWith(&self.r#isic_v_4)
1668				})?;
1669			} else {
1670				serialize_struct.skip_field("isicV4")?;
1671			}
1672			if !Vec::is_empty(&self.r#job_title) {
1673				serialize_struct.serialize_field("jobTitle", {
1674					struct SerializeWith<'a>(&'a Vec<JobTitleProperty>);
1675					impl<'a> Serialize for SerializeWith<'a> {
1676						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1677						where
1678							S: Serializer,
1679						{
1680							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1681								self.0, serializer,
1682							)
1683						}
1684					}
1685					&SerializeWith(&self.r#job_title)
1686				})?;
1687			} else {
1688				serialize_struct.skip_field("jobTitle")?;
1689			}
1690			if !Vec::is_empty(&self.r#knows) {
1691				serialize_struct.serialize_field("knows", {
1692					struct SerializeWith<'a>(&'a Vec<KnowsProperty>);
1693					impl<'a> Serialize for SerializeWith<'a> {
1694						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1695						where
1696							S: Serializer,
1697						{
1698							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1699								self.0, serializer,
1700							)
1701						}
1702					}
1703					&SerializeWith(&self.r#knows)
1704				})?;
1705			} else {
1706				serialize_struct.skip_field("knows")?;
1707			}
1708			if !Vec::is_empty(&self.r#knows_about) {
1709				serialize_struct.serialize_field("knowsAbout", {
1710					struct SerializeWith<'a>(&'a Vec<KnowsAboutProperty>);
1711					impl<'a> Serialize for SerializeWith<'a> {
1712						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1713						where
1714							S: Serializer,
1715						{
1716							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1717								self.0, serializer,
1718							)
1719						}
1720					}
1721					&SerializeWith(&self.r#knows_about)
1722				})?;
1723			} else {
1724				serialize_struct.skip_field("knowsAbout")?;
1725			}
1726			if !Vec::is_empty(&self.r#knows_language) {
1727				serialize_struct.serialize_field("knowsLanguage", {
1728					struct SerializeWith<'a>(&'a Vec<KnowsLanguageProperty>);
1729					impl<'a> Serialize for SerializeWith<'a> {
1730						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1731						where
1732							S: Serializer,
1733						{
1734							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1735								self.0, serializer,
1736							)
1737						}
1738					}
1739					&SerializeWith(&self.r#knows_language)
1740				})?;
1741			} else {
1742				serialize_struct.skip_field("knowsLanguage")?;
1743			}
1744			if !Vec::is_empty(&self.r#makes_offer) {
1745				serialize_struct.serialize_field("makesOffer", {
1746					struct SerializeWith<'a>(&'a Vec<MakesOfferProperty>);
1747					impl<'a> Serialize for SerializeWith<'a> {
1748						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1749						where
1750							S: Serializer,
1751						{
1752							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1753								self.0, serializer,
1754							)
1755						}
1756					}
1757					&SerializeWith(&self.r#makes_offer)
1758				})?;
1759			} else {
1760				serialize_struct.skip_field("makesOffer")?;
1761			}
1762			if !Vec::is_empty(&self.r#member_of) {
1763				serialize_struct.serialize_field("memberOf", {
1764					struct SerializeWith<'a>(&'a Vec<MemberOfProperty>);
1765					impl<'a> Serialize for SerializeWith<'a> {
1766						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1767						where
1768							S: Serializer,
1769						{
1770							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1771								self.0, serializer,
1772							)
1773						}
1774					}
1775					&SerializeWith(&self.r#member_of)
1776				})?;
1777			} else {
1778				serialize_struct.skip_field("memberOf")?;
1779			}
1780			if !Vec::is_empty(&self.r#naics) {
1781				serialize_struct.serialize_field("naics", {
1782					struct SerializeWith<'a>(&'a Vec<NaicsProperty>);
1783					impl<'a> Serialize for SerializeWith<'a> {
1784						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1785						where
1786							S: Serializer,
1787						{
1788							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1789								self.0, serializer,
1790							)
1791						}
1792					}
1793					&SerializeWith(&self.r#naics)
1794				})?;
1795			} else {
1796				serialize_struct.skip_field("naics")?;
1797			}
1798			if !Vec::is_empty(&self.r#nationality) {
1799				serialize_struct.serialize_field("nationality", {
1800					struct SerializeWith<'a>(&'a Vec<NationalityProperty>);
1801					impl<'a> Serialize for SerializeWith<'a> {
1802						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1803						where
1804							S: Serializer,
1805						{
1806							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1807								self.0, serializer,
1808							)
1809						}
1810					}
1811					&SerializeWith(&self.r#nationality)
1812				})?;
1813			} else {
1814				serialize_struct.skip_field("nationality")?;
1815			}
1816			if !Vec::is_empty(&self.r#net_worth) {
1817				serialize_struct.serialize_field("netWorth", {
1818					struct SerializeWith<'a>(&'a Vec<NetWorthProperty>);
1819					impl<'a> Serialize for SerializeWith<'a> {
1820						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1821						where
1822							S: Serializer,
1823						{
1824							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1825								self.0, serializer,
1826							)
1827						}
1828					}
1829					&SerializeWith(&self.r#net_worth)
1830				})?;
1831			} else {
1832				serialize_struct.skip_field("netWorth")?;
1833			}
1834			if !Vec::is_empty(&self.r#owns) {
1835				serialize_struct.serialize_field("owns", {
1836					struct SerializeWith<'a>(&'a Vec<OwnsProperty>);
1837					impl<'a> Serialize for SerializeWith<'a> {
1838						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1839						where
1840							S: Serializer,
1841						{
1842							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1843								self.0, serializer,
1844							)
1845						}
1846					}
1847					&SerializeWith(&self.r#owns)
1848				})?;
1849			} else {
1850				serialize_struct.skip_field("owns")?;
1851			}
1852			if !Vec::is_empty(&self.r#parent) {
1853				serialize_struct.serialize_field("parent", {
1854					struct SerializeWith<'a>(&'a Vec<ParentProperty>);
1855					impl<'a> Serialize for SerializeWith<'a> {
1856						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1857						where
1858							S: Serializer,
1859						{
1860							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1861								self.0, serializer,
1862							)
1863						}
1864					}
1865					&SerializeWith(&self.r#parent)
1866				})?;
1867			} else {
1868				serialize_struct.skip_field("parent")?;
1869			}
1870			if !Vec::is_empty(&self.r#parents) {
1871				serialize_struct.serialize_field("parents", {
1872					struct SerializeWith<'a>(&'a Vec<ParentsProperty>);
1873					impl<'a> Serialize for SerializeWith<'a> {
1874						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1875						where
1876							S: Serializer,
1877						{
1878							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1879								self.0, serializer,
1880							)
1881						}
1882					}
1883					&SerializeWith(&self.r#parents)
1884				})?;
1885			} else {
1886				serialize_struct.skip_field("parents")?;
1887			}
1888			if !Vec::is_empty(&self.r#performer_in) {
1889				serialize_struct.serialize_field("performerIn", {
1890					struct SerializeWith<'a>(&'a Vec<PerformerInProperty>);
1891					impl<'a> Serialize for SerializeWith<'a> {
1892						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1893						where
1894							S: Serializer,
1895						{
1896							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1897								self.0, serializer,
1898							)
1899						}
1900					}
1901					&SerializeWith(&self.r#performer_in)
1902				})?;
1903			} else {
1904				serialize_struct.skip_field("performerIn")?;
1905			}
1906			if !Vec::is_empty(&self.r#publishing_principles) {
1907				serialize_struct.serialize_field("publishingPrinciples", {
1908					struct SerializeWith<'a>(&'a Vec<PublishingPrinciplesProperty>);
1909					impl<'a> Serialize for SerializeWith<'a> {
1910						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1911						where
1912							S: Serializer,
1913						{
1914							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1915								self.0, serializer,
1916							)
1917						}
1918					}
1919					&SerializeWith(&self.r#publishing_principles)
1920				})?;
1921			} else {
1922				serialize_struct.skip_field("publishingPrinciples")?;
1923			}
1924			if !Vec::is_empty(&self.r#related_to) {
1925				serialize_struct.serialize_field("relatedTo", {
1926					struct SerializeWith<'a>(&'a Vec<RelatedToProperty>);
1927					impl<'a> Serialize for SerializeWith<'a> {
1928						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1929						where
1930							S: Serializer,
1931						{
1932							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1933								self.0, serializer,
1934							)
1935						}
1936					}
1937					&SerializeWith(&self.r#related_to)
1938				})?;
1939			} else {
1940				serialize_struct.skip_field("relatedTo")?;
1941			}
1942			if !Vec::is_empty(&self.r#seeks) {
1943				serialize_struct.serialize_field("seeks", {
1944					struct SerializeWith<'a>(&'a Vec<SeeksProperty>);
1945					impl<'a> Serialize for SerializeWith<'a> {
1946						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1947						where
1948							S: Serializer,
1949						{
1950							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1951								self.0, serializer,
1952							)
1953						}
1954					}
1955					&SerializeWith(&self.r#seeks)
1956				})?;
1957			} else {
1958				serialize_struct.skip_field("seeks")?;
1959			}
1960			if !Vec::is_empty(&self.r#sibling) {
1961				serialize_struct.serialize_field("sibling", {
1962					struct SerializeWith<'a>(&'a Vec<SiblingProperty>);
1963					impl<'a> Serialize for SerializeWith<'a> {
1964						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1965						where
1966							S: Serializer,
1967						{
1968							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1969								self.0, serializer,
1970							)
1971						}
1972					}
1973					&SerializeWith(&self.r#sibling)
1974				})?;
1975			} else {
1976				serialize_struct.skip_field("sibling")?;
1977			}
1978			if !Vec::is_empty(&self.r#siblings) {
1979				serialize_struct.serialize_field("siblings", {
1980					struct SerializeWith<'a>(&'a Vec<SiblingsProperty>);
1981					impl<'a> Serialize for SerializeWith<'a> {
1982						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1983						where
1984							S: Serializer,
1985						{
1986							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1987								self.0, serializer,
1988							)
1989						}
1990					}
1991					&SerializeWith(&self.r#siblings)
1992				})?;
1993			} else {
1994				serialize_struct.skip_field("siblings")?;
1995			}
1996			if !Vec::is_empty(&self.r#sponsor) {
1997				serialize_struct.serialize_field("sponsor", {
1998					struct SerializeWith<'a>(&'a Vec<SponsorProperty>);
1999					impl<'a> Serialize for SerializeWith<'a> {
2000						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2001						where
2002							S: Serializer,
2003						{
2004							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2005								self.0, serializer,
2006							)
2007						}
2008					}
2009					&SerializeWith(&self.r#sponsor)
2010				})?;
2011			} else {
2012				serialize_struct.skip_field("sponsor")?;
2013			}
2014			if !Vec::is_empty(&self.r#spouse) {
2015				serialize_struct.serialize_field("spouse", {
2016					struct SerializeWith<'a>(&'a Vec<SpouseProperty>);
2017					impl<'a> Serialize for SerializeWith<'a> {
2018						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2019						where
2020							S: Serializer,
2021						{
2022							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2023								self.0, serializer,
2024							)
2025						}
2026					}
2027					&SerializeWith(&self.r#spouse)
2028				})?;
2029			} else {
2030				serialize_struct.skip_field("spouse")?;
2031			}
2032			if !Vec::is_empty(&self.r#tax_id) {
2033				serialize_struct.serialize_field("taxID", {
2034					struct SerializeWith<'a>(&'a Vec<TaxIdProperty>);
2035					impl<'a> Serialize for SerializeWith<'a> {
2036						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2037						where
2038							S: Serializer,
2039						{
2040							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2041								self.0, serializer,
2042							)
2043						}
2044					}
2045					&SerializeWith(&self.r#tax_id)
2046				})?;
2047			} else {
2048				serialize_struct.skip_field("taxID")?;
2049			}
2050			if !Vec::is_empty(&self.r#telephone) {
2051				serialize_struct.serialize_field("telephone", {
2052					struct SerializeWith<'a>(&'a Vec<TelephoneProperty>);
2053					impl<'a> Serialize for SerializeWith<'a> {
2054						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2055						where
2056							S: Serializer,
2057						{
2058							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2059								self.0, serializer,
2060							)
2061						}
2062					}
2063					&SerializeWith(&self.r#telephone)
2064				})?;
2065			} else {
2066				serialize_struct.skip_field("telephone")?;
2067			}
2068			if !Vec::is_empty(&self.r#vat_id) {
2069				serialize_struct.serialize_field("vatID", {
2070					struct SerializeWith<'a>(&'a Vec<VatIdProperty>);
2071					impl<'a> Serialize for SerializeWith<'a> {
2072						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2073						where
2074							S: Serializer,
2075						{
2076							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2077								self.0, serializer,
2078							)
2079						}
2080					}
2081					&SerializeWith(&self.r#vat_id)
2082				})?;
2083			} else {
2084				serialize_struct.skip_field("vatID")?;
2085			}
2086			if !Vec::is_empty(&self.r#weight) {
2087				serialize_struct.serialize_field("weight", {
2088					struct SerializeWith<'a>(&'a Vec<WeightProperty>);
2089					impl<'a> Serialize for SerializeWith<'a> {
2090						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2091						where
2092							S: Serializer,
2093						{
2094							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2095								self.0, serializer,
2096							)
2097						}
2098					}
2099					&SerializeWith(&self.r#weight)
2100				})?;
2101			} else {
2102				serialize_struct.skip_field("weight")?;
2103			}
2104			if !Vec::is_empty(&self.r#work_location) {
2105				serialize_struct.serialize_field("workLocation", {
2106					struct SerializeWith<'a>(&'a Vec<WorkLocationProperty>);
2107					impl<'a> Serialize for SerializeWith<'a> {
2108						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2109						where
2110							S: Serializer,
2111						{
2112							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2113								self.0, serializer,
2114							)
2115						}
2116					}
2117					&SerializeWith(&self.r#work_location)
2118				})?;
2119			} else {
2120				serialize_struct.skip_field("workLocation")?;
2121			}
2122			if !Vec::is_empty(&self.r#works_for) {
2123				serialize_struct.serialize_field("worksFor", {
2124					struct SerializeWith<'a>(&'a Vec<WorksForProperty>);
2125					impl<'a> Serialize for SerializeWith<'a> {
2126						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2127						where
2128							S: Serializer,
2129						{
2130							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2131								self.0, serializer,
2132							)
2133						}
2134					}
2135					&SerializeWith(&self.r#works_for)
2136				})?;
2137			} else {
2138				serialize_struct.skip_field("worksFor")?;
2139			}
2140			if !Vec::is_empty(&self.r#additional_type) {
2141				serialize_struct.serialize_field("additionalType", {
2142					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
2143					impl<'a> Serialize for SerializeWith<'a> {
2144						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2145						where
2146							S: Serializer,
2147						{
2148							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2149								self.0, serializer,
2150							)
2151						}
2152					}
2153					&SerializeWith(&self.r#additional_type)
2154				})?;
2155			} else {
2156				serialize_struct.skip_field("additionalType")?;
2157			}
2158			if !Vec::is_empty(&self.r#alternate_name) {
2159				serialize_struct.serialize_field("alternateName", {
2160					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
2161					impl<'a> Serialize for SerializeWith<'a> {
2162						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2163						where
2164							S: Serializer,
2165						{
2166							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2167								self.0, serializer,
2168							)
2169						}
2170					}
2171					&SerializeWith(&self.r#alternate_name)
2172				})?;
2173			} else {
2174				serialize_struct.skip_field("alternateName")?;
2175			}
2176			if !Vec::is_empty(&self.r#description) {
2177				serialize_struct.serialize_field("description", {
2178					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
2179					impl<'a> Serialize for SerializeWith<'a> {
2180						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2181						where
2182							S: Serializer,
2183						{
2184							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2185								self.0, serializer,
2186							)
2187						}
2188					}
2189					&SerializeWith(&self.r#description)
2190				})?;
2191			} else {
2192				serialize_struct.skip_field("description")?;
2193			}
2194			if !Vec::is_empty(&self.r#disambiguating_description) {
2195				serialize_struct.serialize_field("disambiguatingDescription", {
2196					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
2197					impl<'a> Serialize for SerializeWith<'a> {
2198						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2199						where
2200							S: Serializer,
2201						{
2202							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2203								self.0, serializer,
2204							)
2205						}
2206					}
2207					&SerializeWith(&self.r#disambiguating_description)
2208				})?;
2209			} else {
2210				serialize_struct.skip_field("disambiguatingDescription")?;
2211			}
2212			if !Vec::is_empty(&self.r#identifier) {
2213				serialize_struct.serialize_field("identifier", {
2214					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
2215					impl<'a> Serialize for SerializeWith<'a> {
2216						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2217						where
2218							S: Serializer,
2219						{
2220							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2221								self.0, serializer,
2222							)
2223						}
2224					}
2225					&SerializeWith(&self.r#identifier)
2226				})?;
2227			} else {
2228				serialize_struct.skip_field("identifier")?;
2229			}
2230			if !Vec::is_empty(&self.r#image) {
2231				serialize_struct.serialize_field("image", {
2232					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
2233					impl<'a> Serialize for SerializeWith<'a> {
2234						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2235						where
2236							S: Serializer,
2237						{
2238							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2239								self.0, serializer,
2240							)
2241						}
2242					}
2243					&SerializeWith(&self.r#image)
2244				})?;
2245			} else {
2246				serialize_struct.skip_field("image")?;
2247			}
2248			if !Vec::is_empty(&self.r#main_entity_of_page) {
2249				serialize_struct.serialize_field("mainEntityOfPage", {
2250					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
2251					impl<'a> Serialize for SerializeWith<'a> {
2252						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2253						where
2254							S: Serializer,
2255						{
2256							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2257								self.0, serializer,
2258							)
2259						}
2260					}
2261					&SerializeWith(&self.r#main_entity_of_page)
2262				})?;
2263			} else {
2264				serialize_struct.skip_field("mainEntityOfPage")?;
2265			}
2266			if !Vec::is_empty(&self.r#name) {
2267				serialize_struct.serialize_field("name", {
2268					struct SerializeWith<'a>(&'a Vec<NameProperty>);
2269					impl<'a> Serialize for SerializeWith<'a> {
2270						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2271						where
2272							S: Serializer,
2273						{
2274							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2275								self.0, serializer,
2276							)
2277						}
2278					}
2279					&SerializeWith(&self.r#name)
2280				})?;
2281			} else {
2282				serialize_struct.skip_field("name")?;
2283			}
2284			if !Vec::is_empty(&self.r#potential_action) {
2285				serialize_struct.serialize_field("potentialAction", {
2286					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
2287					impl<'a> Serialize for SerializeWith<'a> {
2288						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2289						where
2290							S: Serializer,
2291						{
2292							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2293								self.0, serializer,
2294							)
2295						}
2296					}
2297					&SerializeWith(&self.r#potential_action)
2298				})?;
2299			} else {
2300				serialize_struct.skip_field("potentialAction")?;
2301			}
2302			if !Vec::is_empty(&self.r#same_as) {
2303				serialize_struct.serialize_field("sameAs", {
2304					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
2305					impl<'a> Serialize for SerializeWith<'a> {
2306						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2307						where
2308							S: Serializer,
2309						{
2310							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2311								self.0, serializer,
2312							)
2313						}
2314					}
2315					&SerializeWith(&self.r#same_as)
2316				})?;
2317			} else {
2318				serialize_struct.skip_field("sameAs")?;
2319			}
2320			if !Vec::is_empty(&self.r#subject_of) {
2321				serialize_struct.serialize_field("subjectOf", {
2322					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
2323					impl<'a> Serialize for SerializeWith<'a> {
2324						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2325						where
2326							S: Serializer,
2327						{
2328							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2329								self.0, serializer,
2330							)
2331						}
2332					}
2333					&SerializeWith(&self.r#subject_of)
2334				})?;
2335			} else {
2336				serialize_struct.skip_field("subjectOf")?;
2337			}
2338			if !Vec::is_empty(&self.r#url) {
2339				serialize_struct.serialize_field("url", {
2340					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
2341					impl<'a> Serialize for SerializeWith<'a> {
2342						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2343						where
2344							S: Serializer,
2345						{
2346							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2347								self.0, serializer,
2348							)
2349						}
2350					}
2351					&SerializeWith(&self.r#url)
2352				})?;
2353			} else {
2354				serialize_struct.skip_field("url")?;
2355			}
2356			serialize_struct.end()
2357		}
2358	}
2359	impl<'de> Deserialize<'de> for Person {
2360		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2361		where
2362			D: Deserializer<'de>,
2363		{
2364			enum Field {
2365				AdditionalName,
2366				Address,
2367				Affiliation,
2368				AgentInteractionStatistic,
2369				AlumniOf,
2370				Award,
2371				Awards,
2372				BirthDate,
2373				BirthPlace,
2374				Brand,
2375				CallSign,
2376				Children,
2377				Colleague,
2378				Colleagues,
2379				ContactPoint,
2380				ContactPoints,
2381				DeathDate,
2382				DeathPlace,
2383				Duns,
2384				Email,
2385				FamilyName,
2386				FaxNumber,
2387				Follows,
2388				Funder,
2389				Funding,
2390				Gender,
2391				GivenName,
2392				GlobalLocationNumber,
2393				HasCredential,
2394				HasOccupation,
2395				HasOfferCatalog,
2396				HasPos,
2397				Height,
2398				HomeLocation,
2399				HonorificPrefix,
2400				HonorificSuffix,
2401				InteractionStatistic,
2402				IsicV4,
2403				JobTitle,
2404				Knows,
2405				KnowsAbout,
2406				KnowsLanguage,
2407				MakesOffer,
2408				MemberOf,
2409				Naics,
2410				Nationality,
2411				NetWorth,
2412				Owns,
2413				Parent,
2414				Parents,
2415				PerformerIn,
2416				PublishingPrinciples,
2417				RelatedTo,
2418				Seeks,
2419				Sibling,
2420				Siblings,
2421				Sponsor,
2422				Spouse,
2423				TaxId,
2424				Telephone,
2425				VatId,
2426				Weight,
2427				WorkLocation,
2428				WorksFor,
2429				AdditionalType,
2430				AlternateName,
2431				Description,
2432				DisambiguatingDescription,
2433				Identifier,
2434				Image,
2435				MainEntityOfPage,
2436				Name,
2437				PotentialAction,
2438				SameAs,
2439				SubjectOf,
2440				Url,
2441				Ignore,
2442			}
2443			struct FieldVisitor;
2444			impl<'de> Visitor<'de> for FieldVisitor {
2445				type Value = Field;
2446				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
2447					formatter.write_str("field identifier")
2448				}
2449				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2450				where
2451					E: de::Error,
2452				{
2453					match value {
2454						"additionalName" => Ok(Field::AdditionalName),
2455						"address" => Ok(Field::Address),
2456						"affiliation" => Ok(Field::Affiliation),
2457						"agentInteractionStatistic" => Ok(Field::AgentInteractionStatistic),
2458						"alumniOf" => Ok(Field::AlumniOf),
2459						"award" => Ok(Field::Award),
2460						"awards" => Ok(Field::Awards),
2461						"birthDate" => Ok(Field::BirthDate),
2462						"birthPlace" => Ok(Field::BirthPlace),
2463						"brand" => Ok(Field::Brand),
2464						"callSign" => Ok(Field::CallSign),
2465						"children" => Ok(Field::Children),
2466						"colleague" => Ok(Field::Colleague),
2467						"colleagues" => Ok(Field::Colleagues),
2468						"contactPoint" => Ok(Field::ContactPoint),
2469						"contactPoints" => Ok(Field::ContactPoints),
2470						"deathDate" => Ok(Field::DeathDate),
2471						"deathPlace" => Ok(Field::DeathPlace),
2472						"duns" => Ok(Field::Duns),
2473						"email" => Ok(Field::Email),
2474						"familyName" => Ok(Field::FamilyName),
2475						"faxNumber" => Ok(Field::FaxNumber),
2476						"follows" => Ok(Field::Follows),
2477						"funder" => Ok(Field::Funder),
2478						"funding" => Ok(Field::Funding),
2479						"gender" => Ok(Field::Gender),
2480						"givenName" => Ok(Field::GivenName),
2481						"globalLocationNumber" => Ok(Field::GlobalLocationNumber),
2482						"hasCredential" => Ok(Field::HasCredential),
2483						"hasOccupation" => Ok(Field::HasOccupation),
2484						"hasOfferCatalog" => Ok(Field::HasOfferCatalog),
2485						"hasPOS" => Ok(Field::HasPos),
2486						"height" => Ok(Field::Height),
2487						"homeLocation" => Ok(Field::HomeLocation),
2488						"honorificPrefix" => Ok(Field::HonorificPrefix),
2489						"honorificSuffix" => Ok(Field::HonorificSuffix),
2490						"interactionStatistic" => Ok(Field::InteractionStatistic),
2491						"isicV4" => Ok(Field::IsicV4),
2492						"jobTitle" => Ok(Field::JobTitle),
2493						"knows" => Ok(Field::Knows),
2494						"knowsAbout" => Ok(Field::KnowsAbout),
2495						"knowsLanguage" => Ok(Field::KnowsLanguage),
2496						"makesOffer" => Ok(Field::MakesOffer),
2497						"memberOf" => Ok(Field::MemberOf),
2498						"naics" => Ok(Field::Naics),
2499						"nationality" => Ok(Field::Nationality),
2500						"netWorth" => Ok(Field::NetWorth),
2501						"owns" => Ok(Field::Owns),
2502						"parent" => Ok(Field::Parent),
2503						"parents" => Ok(Field::Parents),
2504						"performerIn" => Ok(Field::PerformerIn),
2505						"publishingPrinciples" => Ok(Field::PublishingPrinciples),
2506						"relatedTo" => Ok(Field::RelatedTo),
2507						"seeks" => Ok(Field::Seeks),
2508						"sibling" => Ok(Field::Sibling),
2509						"siblings" => Ok(Field::Siblings),
2510						"sponsor" => Ok(Field::Sponsor),
2511						"spouse" => Ok(Field::Spouse),
2512						"taxID" => Ok(Field::TaxId),
2513						"telephone" => Ok(Field::Telephone),
2514						"vatID" => Ok(Field::VatId),
2515						"weight" => Ok(Field::Weight),
2516						"workLocation" => Ok(Field::WorkLocation),
2517						"worksFor" => Ok(Field::WorksFor),
2518						"additionalType" => Ok(Field::AdditionalType),
2519						"alternateName" => Ok(Field::AlternateName),
2520						"description" => Ok(Field::Description),
2521						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
2522						"identifier" => Ok(Field::Identifier),
2523						"image" => Ok(Field::Image),
2524						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
2525						"name" => Ok(Field::Name),
2526						"potentialAction" => Ok(Field::PotentialAction),
2527						"sameAs" => Ok(Field::SameAs),
2528						"subjectOf" => Ok(Field::SubjectOf),
2529						"url" => Ok(Field::Url),
2530						"id" | "type" => Ok(Field::Ignore),
2531						_ => Err(de::Error::unknown_field(value, FIELDS)),
2532					}
2533				}
2534				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2535				where
2536					E: de::Error,
2537				{
2538					match value {
2539						b"additionalName" => Ok(Field::AdditionalName),
2540						b"address" => Ok(Field::Address),
2541						b"affiliation" => Ok(Field::Affiliation),
2542						b"agentInteractionStatistic" => Ok(Field::AgentInteractionStatistic),
2543						b"alumniOf" => Ok(Field::AlumniOf),
2544						b"award" => Ok(Field::Award),
2545						b"awards" => Ok(Field::Awards),
2546						b"birthDate" => Ok(Field::BirthDate),
2547						b"birthPlace" => Ok(Field::BirthPlace),
2548						b"brand" => Ok(Field::Brand),
2549						b"callSign" => Ok(Field::CallSign),
2550						b"children" => Ok(Field::Children),
2551						b"colleague" => Ok(Field::Colleague),
2552						b"colleagues" => Ok(Field::Colleagues),
2553						b"contactPoint" => Ok(Field::ContactPoint),
2554						b"contactPoints" => Ok(Field::ContactPoints),
2555						b"deathDate" => Ok(Field::DeathDate),
2556						b"deathPlace" => Ok(Field::DeathPlace),
2557						b"duns" => Ok(Field::Duns),
2558						b"email" => Ok(Field::Email),
2559						b"familyName" => Ok(Field::FamilyName),
2560						b"faxNumber" => Ok(Field::FaxNumber),
2561						b"follows" => Ok(Field::Follows),
2562						b"funder" => Ok(Field::Funder),
2563						b"funding" => Ok(Field::Funding),
2564						b"gender" => Ok(Field::Gender),
2565						b"givenName" => Ok(Field::GivenName),
2566						b"globalLocationNumber" => Ok(Field::GlobalLocationNumber),
2567						b"hasCredential" => Ok(Field::HasCredential),
2568						b"hasOccupation" => Ok(Field::HasOccupation),
2569						b"hasOfferCatalog" => Ok(Field::HasOfferCatalog),
2570						b"hasPOS" => Ok(Field::HasPos),
2571						b"height" => Ok(Field::Height),
2572						b"homeLocation" => Ok(Field::HomeLocation),
2573						b"honorificPrefix" => Ok(Field::HonorificPrefix),
2574						b"honorificSuffix" => Ok(Field::HonorificSuffix),
2575						b"interactionStatistic" => Ok(Field::InteractionStatistic),
2576						b"isicV4" => Ok(Field::IsicV4),
2577						b"jobTitle" => Ok(Field::JobTitle),
2578						b"knows" => Ok(Field::Knows),
2579						b"knowsAbout" => Ok(Field::KnowsAbout),
2580						b"knowsLanguage" => Ok(Field::KnowsLanguage),
2581						b"makesOffer" => Ok(Field::MakesOffer),
2582						b"memberOf" => Ok(Field::MemberOf),
2583						b"naics" => Ok(Field::Naics),
2584						b"nationality" => Ok(Field::Nationality),
2585						b"netWorth" => Ok(Field::NetWorth),
2586						b"owns" => Ok(Field::Owns),
2587						b"parent" => Ok(Field::Parent),
2588						b"parents" => Ok(Field::Parents),
2589						b"performerIn" => Ok(Field::PerformerIn),
2590						b"publishingPrinciples" => Ok(Field::PublishingPrinciples),
2591						b"relatedTo" => Ok(Field::RelatedTo),
2592						b"seeks" => Ok(Field::Seeks),
2593						b"sibling" => Ok(Field::Sibling),
2594						b"siblings" => Ok(Field::Siblings),
2595						b"sponsor" => Ok(Field::Sponsor),
2596						b"spouse" => Ok(Field::Spouse),
2597						b"taxID" => Ok(Field::TaxId),
2598						b"telephone" => Ok(Field::Telephone),
2599						b"vatID" => Ok(Field::VatId),
2600						b"weight" => Ok(Field::Weight),
2601						b"workLocation" => Ok(Field::WorkLocation),
2602						b"worksFor" => Ok(Field::WorksFor),
2603						b"additionalType" => Ok(Field::AdditionalType),
2604						b"alternateName" => Ok(Field::AlternateName),
2605						b"description" => Ok(Field::Description),
2606						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
2607						b"identifier" => Ok(Field::Identifier),
2608						b"image" => Ok(Field::Image),
2609						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
2610						b"name" => Ok(Field::Name),
2611						b"potentialAction" => Ok(Field::PotentialAction),
2612						b"sameAs" => Ok(Field::SameAs),
2613						b"subjectOf" => Ok(Field::SubjectOf),
2614						b"url" => Ok(Field::Url),
2615						b"id" | b"type" => Ok(Field::Ignore),
2616						_ => {
2617							let value = &String::from_utf8_lossy(value);
2618							Err(de::Error::unknown_field(value, FIELDS))
2619						}
2620					}
2621				}
2622			}
2623			impl<'de> Deserialize<'de> for Field {
2624				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2625				where
2626					D: Deserializer<'de>,
2627				{
2628					deserializer.deserialize_identifier(FieldVisitor)
2629				}
2630			}
2631			struct ClassVisitor;
2632			impl<'de> Visitor<'de> for ClassVisitor {
2633				type Value = Person;
2634				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
2635					formatter.write_str("schema.org schema Person")
2636				}
2637				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2638				where
2639					A: de::MapAccess<'de>,
2640				{
2641					let mut r#additional_name_property = None;
2642					let mut r#address_property = None;
2643					let mut r#affiliation_property = None;
2644					let mut r#agent_interaction_statistic_property = None;
2645					let mut r#alumni_of_property = None;
2646					let mut r#award_property = None;
2647					let mut r#awards_property = None;
2648					let mut r#birth_date_property = None;
2649					let mut r#birth_place_property = None;
2650					let mut r#brand_property = None;
2651					let mut r#call_sign_property = None;
2652					let mut r#children_property = None;
2653					let mut r#colleague_property = None;
2654					let mut r#colleagues_property = None;
2655					let mut r#contact_point_property = None;
2656					let mut r#contact_points_property = None;
2657					let mut r#death_date_property = None;
2658					let mut r#death_place_property = None;
2659					let mut r#duns_property = None;
2660					let mut r#email_property = None;
2661					let mut r#family_name_property = None;
2662					let mut r#fax_number_property = None;
2663					let mut r#follows_property = None;
2664					let mut r#funder_property = None;
2665					let mut r#funding_property = None;
2666					let mut r#gender_property = None;
2667					let mut r#given_name_property = None;
2668					let mut r#global_location_number_property = None;
2669					let mut r#has_credential_property = None;
2670					let mut r#has_occupation_property = None;
2671					let mut r#has_offer_catalog_property = None;
2672					let mut r#has_pos_property = None;
2673					let mut r#height_property = None;
2674					let mut r#home_location_property = None;
2675					let mut r#honorific_prefix_property = None;
2676					let mut r#honorific_suffix_property = None;
2677					let mut r#interaction_statistic_property = None;
2678					let mut r#isic_v_4_property = None;
2679					let mut r#job_title_property = None;
2680					let mut r#knows_property = None;
2681					let mut r#knows_about_property = None;
2682					let mut r#knows_language_property = None;
2683					let mut r#makes_offer_property = None;
2684					let mut r#member_of_property = None;
2685					let mut r#naics_property = None;
2686					let mut r#nationality_property = None;
2687					let mut r#net_worth_property = None;
2688					let mut r#owns_property = None;
2689					let mut r#parent_property = None;
2690					let mut r#parents_property = None;
2691					let mut r#performer_in_property = None;
2692					let mut r#publishing_principles_property = None;
2693					let mut r#related_to_property = None;
2694					let mut r#seeks_property = None;
2695					let mut r#sibling_property = None;
2696					let mut r#siblings_property = None;
2697					let mut r#sponsor_property = None;
2698					let mut r#spouse_property = None;
2699					let mut r#tax_id_property = None;
2700					let mut r#telephone_property = None;
2701					let mut r#vat_id_property = None;
2702					let mut r#weight_property = None;
2703					let mut r#work_location_property = None;
2704					let mut r#works_for_property = None;
2705					let mut r#additional_type_property = None;
2706					let mut r#alternate_name_property = None;
2707					let mut r#description_property = None;
2708					let mut r#disambiguating_description_property = None;
2709					let mut r#identifier_property = None;
2710					let mut r#image_property = None;
2711					let mut r#main_entity_of_page_property = None;
2712					let mut r#name_property = None;
2713					let mut r#potential_action_property = None;
2714					let mut r#same_as_property = None;
2715					let mut r#subject_of_property = None;
2716					let mut r#url_property = None;
2717					while let Some(key) = map.next_key::<Field>()? {
2718						match key {
2719							Field::AdditionalName => {
2720								if r#additional_name_property.is_some() {
2721									return Err(<A::Error as de::Error>::duplicate_field(
2722										"additionalName",
2723									));
2724								}
2725								r#additional_name_property = Some({
2726									struct DeserializeWith(Vec<AdditionalNameProperty>);
2727									impl<'de> Deserialize<'de> for DeserializeWith {
2728										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2729										where
2730											D: Deserializer<'de>,
2731										{
2732											Ok(DeserializeWith(serde_with::As::<
2733												serde_with::OneOrMany<serde_with::Same>,
2734											>::deserialize(deserializer)?))
2735										}
2736									}
2737									match map.next_value::<DeserializeWith>() {
2738										Ok(deserialize_with) => deserialize_with.0,
2739										Err(err) => {
2740											return Err(err);
2741										}
2742									}
2743								});
2744							}
2745							Field::Address => {
2746								if r#address_property.is_some() {
2747									return Err(<A::Error as de::Error>::duplicate_field(
2748										"address",
2749									));
2750								}
2751								r#address_property = Some({
2752									struct DeserializeWith(Vec<AddressProperty>);
2753									impl<'de> Deserialize<'de> for DeserializeWith {
2754										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2755										where
2756											D: Deserializer<'de>,
2757										{
2758											Ok(DeserializeWith(serde_with::As::<
2759												serde_with::OneOrMany<serde_with::Same>,
2760											>::deserialize(deserializer)?))
2761										}
2762									}
2763									match map.next_value::<DeserializeWith>() {
2764										Ok(deserialize_with) => deserialize_with.0,
2765										Err(err) => {
2766											return Err(err);
2767										}
2768									}
2769								});
2770							}
2771							Field::Affiliation => {
2772								if r#affiliation_property.is_some() {
2773									return Err(<A::Error as de::Error>::duplicate_field(
2774										"affiliation",
2775									));
2776								}
2777								r#affiliation_property = Some({
2778									struct DeserializeWith(Vec<AffiliationProperty>);
2779									impl<'de> Deserialize<'de> for DeserializeWith {
2780										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2781										where
2782											D: Deserializer<'de>,
2783										{
2784											Ok(DeserializeWith(serde_with::As::<
2785												serde_with::OneOrMany<serde_with::Same>,
2786											>::deserialize(deserializer)?))
2787										}
2788									}
2789									match map.next_value::<DeserializeWith>() {
2790										Ok(deserialize_with) => deserialize_with.0,
2791										Err(err) => {
2792											return Err(err);
2793										}
2794									}
2795								});
2796							}
2797							Field::AgentInteractionStatistic => {
2798								if r#agent_interaction_statistic_property.is_some() {
2799									return Err(<A::Error as de::Error>::duplicate_field(
2800										"agentInteractionStatistic",
2801									));
2802								}
2803								r#agent_interaction_statistic_property = Some({
2804									struct DeserializeWith(Vec<AgentInteractionStatisticProperty>);
2805									impl<'de> Deserialize<'de> for DeserializeWith {
2806										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2807										where
2808											D: Deserializer<'de>,
2809										{
2810											Ok(DeserializeWith(serde_with::As::<
2811												serde_with::OneOrMany<serde_with::Same>,
2812											>::deserialize(deserializer)?))
2813										}
2814									}
2815									match map.next_value::<DeserializeWith>() {
2816										Ok(deserialize_with) => deserialize_with.0,
2817										Err(err) => {
2818											return Err(err);
2819										}
2820									}
2821								});
2822							}
2823							Field::AlumniOf => {
2824								if r#alumni_of_property.is_some() {
2825									return Err(<A::Error as de::Error>::duplicate_field(
2826										"alumniOf",
2827									));
2828								}
2829								r#alumni_of_property = Some({
2830									struct DeserializeWith(Vec<AlumniOfProperty>);
2831									impl<'de> Deserialize<'de> for DeserializeWith {
2832										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2833										where
2834											D: Deserializer<'de>,
2835										{
2836											Ok(DeserializeWith(serde_with::As::<
2837												serde_with::OneOrMany<serde_with::Same>,
2838											>::deserialize(deserializer)?))
2839										}
2840									}
2841									match map.next_value::<DeserializeWith>() {
2842										Ok(deserialize_with) => deserialize_with.0,
2843										Err(err) => {
2844											return Err(err);
2845										}
2846									}
2847								});
2848							}
2849							Field::Award => {
2850								if r#award_property.is_some() {
2851									return Err(<A::Error as de::Error>::duplicate_field("award"));
2852								}
2853								r#award_property = Some({
2854									struct DeserializeWith(Vec<AwardProperty>);
2855									impl<'de> Deserialize<'de> for DeserializeWith {
2856										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2857										where
2858											D: Deserializer<'de>,
2859										{
2860											Ok(DeserializeWith(serde_with::As::<
2861												serde_with::OneOrMany<serde_with::Same>,
2862											>::deserialize(deserializer)?))
2863										}
2864									}
2865									match map.next_value::<DeserializeWith>() {
2866										Ok(deserialize_with) => deserialize_with.0,
2867										Err(err) => {
2868											return Err(err);
2869										}
2870									}
2871								});
2872							}
2873							Field::Awards => {
2874								if r#awards_property.is_some() {
2875									return Err(<A::Error as de::Error>::duplicate_field("awards"));
2876								}
2877								r#awards_property = Some({
2878									struct DeserializeWith(Vec<AwardsProperty>);
2879									impl<'de> Deserialize<'de> for DeserializeWith {
2880										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2881										where
2882											D: Deserializer<'de>,
2883										{
2884											Ok(DeserializeWith(serde_with::As::<
2885												serde_with::OneOrMany<serde_with::Same>,
2886											>::deserialize(deserializer)?))
2887										}
2888									}
2889									match map.next_value::<DeserializeWith>() {
2890										Ok(deserialize_with) => deserialize_with.0,
2891										Err(err) => {
2892											return Err(err);
2893										}
2894									}
2895								});
2896							}
2897							Field::BirthDate => {
2898								if r#birth_date_property.is_some() {
2899									return Err(<A::Error as de::Error>::duplicate_field(
2900										"birthDate",
2901									));
2902								}
2903								r#birth_date_property = Some({
2904									struct DeserializeWith(Vec<BirthDateProperty>);
2905									impl<'de> Deserialize<'de> for DeserializeWith {
2906										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2907										where
2908											D: Deserializer<'de>,
2909										{
2910											Ok(DeserializeWith(serde_with::As::<
2911												serde_with::OneOrMany<serde_with::Same>,
2912											>::deserialize(deserializer)?))
2913										}
2914									}
2915									match map.next_value::<DeserializeWith>() {
2916										Ok(deserialize_with) => deserialize_with.0,
2917										Err(err) => {
2918											return Err(err);
2919										}
2920									}
2921								});
2922							}
2923							Field::BirthPlace => {
2924								if r#birth_place_property.is_some() {
2925									return Err(<A::Error as de::Error>::duplicate_field(
2926										"birthPlace",
2927									));
2928								}
2929								r#birth_place_property = Some({
2930									struct DeserializeWith(Vec<BirthPlaceProperty>);
2931									impl<'de> Deserialize<'de> for DeserializeWith {
2932										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2933										where
2934											D: Deserializer<'de>,
2935										{
2936											Ok(DeserializeWith(serde_with::As::<
2937												serde_with::OneOrMany<serde_with::Same>,
2938											>::deserialize(deserializer)?))
2939										}
2940									}
2941									match map.next_value::<DeserializeWith>() {
2942										Ok(deserialize_with) => deserialize_with.0,
2943										Err(err) => {
2944											return Err(err);
2945										}
2946									}
2947								});
2948							}
2949							Field::Brand => {
2950								if r#brand_property.is_some() {
2951									return Err(<A::Error as de::Error>::duplicate_field("brand"));
2952								}
2953								r#brand_property = Some({
2954									struct DeserializeWith(Vec<BrandProperty>);
2955									impl<'de> Deserialize<'de> for DeserializeWith {
2956										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2957										where
2958											D: Deserializer<'de>,
2959										{
2960											Ok(DeserializeWith(serde_with::As::<
2961												serde_with::OneOrMany<serde_with::Same>,
2962											>::deserialize(deserializer)?))
2963										}
2964									}
2965									match map.next_value::<DeserializeWith>() {
2966										Ok(deserialize_with) => deserialize_with.0,
2967										Err(err) => {
2968											return Err(err);
2969										}
2970									}
2971								});
2972							}
2973							Field::CallSign => {
2974								if r#call_sign_property.is_some() {
2975									return Err(<A::Error as de::Error>::duplicate_field(
2976										"callSign",
2977									));
2978								}
2979								r#call_sign_property = Some({
2980									struct DeserializeWith(Vec<CallSignProperty>);
2981									impl<'de> Deserialize<'de> for DeserializeWith {
2982										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2983										where
2984											D: Deserializer<'de>,
2985										{
2986											Ok(DeserializeWith(serde_with::As::<
2987												serde_with::OneOrMany<serde_with::Same>,
2988											>::deserialize(deserializer)?))
2989										}
2990									}
2991									match map.next_value::<DeserializeWith>() {
2992										Ok(deserialize_with) => deserialize_with.0,
2993										Err(err) => {
2994											return Err(err);
2995										}
2996									}
2997								});
2998							}
2999							Field::Children => {
3000								if r#children_property.is_some() {
3001									return Err(<A::Error as de::Error>::duplicate_field(
3002										"children",
3003									));
3004								}
3005								r#children_property = Some({
3006									struct DeserializeWith(Vec<ChildrenProperty>);
3007									impl<'de> Deserialize<'de> for DeserializeWith {
3008										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3009										where
3010											D: Deserializer<'de>,
3011										{
3012											Ok(DeserializeWith(serde_with::As::<
3013												serde_with::OneOrMany<serde_with::Same>,
3014											>::deserialize(deserializer)?))
3015										}
3016									}
3017									match map.next_value::<DeserializeWith>() {
3018										Ok(deserialize_with) => deserialize_with.0,
3019										Err(err) => {
3020											return Err(err);
3021										}
3022									}
3023								});
3024							}
3025							Field::Colleague => {
3026								if r#colleague_property.is_some() {
3027									return Err(<A::Error as de::Error>::duplicate_field(
3028										"colleague",
3029									));
3030								}
3031								r#colleague_property = Some({
3032									struct DeserializeWith(Vec<ColleagueProperty>);
3033									impl<'de> Deserialize<'de> for DeserializeWith {
3034										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3035										where
3036											D: Deserializer<'de>,
3037										{
3038											Ok(DeserializeWith(serde_with::As::<
3039												serde_with::OneOrMany<serde_with::Same>,
3040											>::deserialize(deserializer)?))
3041										}
3042									}
3043									match map.next_value::<DeserializeWith>() {
3044										Ok(deserialize_with) => deserialize_with.0,
3045										Err(err) => {
3046											return Err(err);
3047										}
3048									}
3049								});
3050							}
3051							Field::Colleagues => {
3052								if r#colleagues_property.is_some() {
3053									return Err(<A::Error as de::Error>::duplicate_field(
3054										"colleagues",
3055									));
3056								}
3057								r#colleagues_property = Some({
3058									struct DeserializeWith(Vec<ColleaguesProperty>);
3059									impl<'de> Deserialize<'de> for DeserializeWith {
3060										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3061										where
3062											D: Deserializer<'de>,
3063										{
3064											Ok(DeserializeWith(serde_with::As::<
3065												serde_with::OneOrMany<serde_with::Same>,
3066											>::deserialize(deserializer)?))
3067										}
3068									}
3069									match map.next_value::<DeserializeWith>() {
3070										Ok(deserialize_with) => deserialize_with.0,
3071										Err(err) => {
3072											return Err(err);
3073										}
3074									}
3075								});
3076							}
3077							Field::ContactPoint => {
3078								if r#contact_point_property.is_some() {
3079									return Err(<A::Error as de::Error>::duplicate_field(
3080										"contactPoint",
3081									));
3082								}
3083								r#contact_point_property = Some({
3084									struct DeserializeWith(Vec<ContactPointProperty>);
3085									impl<'de> Deserialize<'de> for DeserializeWith {
3086										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3087										where
3088											D: Deserializer<'de>,
3089										{
3090											Ok(DeserializeWith(serde_with::As::<
3091												serde_with::OneOrMany<serde_with::Same>,
3092											>::deserialize(deserializer)?))
3093										}
3094									}
3095									match map.next_value::<DeserializeWith>() {
3096										Ok(deserialize_with) => deserialize_with.0,
3097										Err(err) => {
3098											return Err(err);
3099										}
3100									}
3101								});
3102							}
3103							Field::ContactPoints => {
3104								if r#contact_points_property.is_some() {
3105									return Err(<A::Error as de::Error>::duplicate_field(
3106										"contactPoints",
3107									));
3108								}
3109								r#contact_points_property = Some({
3110									struct DeserializeWith(Vec<ContactPointsProperty>);
3111									impl<'de> Deserialize<'de> for DeserializeWith {
3112										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3113										where
3114											D: Deserializer<'de>,
3115										{
3116											Ok(DeserializeWith(serde_with::As::<
3117												serde_with::OneOrMany<serde_with::Same>,
3118											>::deserialize(deserializer)?))
3119										}
3120									}
3121									match map.next_value::<DeserializeWith>() {
3122										Ok(deserialize_with) => deserialize_with.0,
3123										Err(err) => {
3124											return Err(err);
3125										}
3126									}
3127								});
3128							}
3129							Field::DeathDate => {
3130								if r#death_date_property.is_some() {
3131									return Err(<A::Error as de::Error>::duplicate_field(
3132										"deathDate",
3133									));
3134								}
3135								r#death_date_property = Some({
3136									struct DeserializeWith(Vec<DeathDateProperty>);
3137									impl<'de> Deserialize<'de> for DeserializeWith {
3138										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3139										where
3140											D: Deserializer<'de>,
3141										{
3142											Ok(DeserializeWith(serde_with::As::<
3143												serde_with::OneOrMany<serde_with::Same>,
3144											>::deserialize(deserializer)?))
3145										}
3146									}
3147									match map.next_value::<DeserializeWith>() {
3148										Ok(deserialize_with) => deserialize_with.0,
3149										Err(err) => {
3150											return Err(err);
3151										}
3152									}
3153								});
3154							}
3155							Field::DeathPlace => {
3156								if r#death_place_property.is_some() {
3157									return Err(<A::Error as de::Error>::duplicate_field(
3158										"deathPlace",
3159									));
3160								}
3161								r#death_place_property = Some({
3162									struct DeserializeWith(Vec<DeathPlaceProperty>);
3163									impl<'de> Deserialize<'de> for DeserializeWith {
3164										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3165										where
3166											D: Deserializer<'de>,
3167										{
3168											Ok(DeserializeWith(serde_with::As::<
3169												serde_with::OneOrMany<serde_with::Same>,
3170											>::deserialize(deserializer)?))
3171										}
3172									}
3173									match map.next_value::<DeserializeWith>() {
3174										Ok(deserialize_with) => deserialize_with.0,
3175										Err(err) => {
3176											return Err(err);
3177										}
3178									}
3179								});
3180							}
3181							Field::Duns => {
3182								if r#duns_property.is_some() {
3183									return Err(<A::Error as de::Error>::duplicate_field("duns"));
3184								}
3185								r#duns_property = Some({
3186									struct DeserializeWith(Vec<DunsProperty>);
3187									impl<'de> Deserialize<'de> for DeserializeWith {
3188										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3189										where
3190											D: Deserializer<'de>,
3191										{
3192											Ok(DeserializeWith(serde_with::As::<
3193												serde_with::OneOrMany<serde_with::Same>,
3194											>::deserialize(deserializer)?))
3195										}
3196									}
3197									match map.next_value::<DeserializeWith>() {
3198										Ok(deserialize_with) => deserialize_with.0,
3199										Err(err) => {
3200											return Err(err);
3201										}
3202									}
3203								});
3204							}
3205							Field::Email => {
3206								if r#email_property.is_some() {
3207									return Err(<A::Error as de::Error>::duplicate_field("email"));
3208								}
3209								r#email_property = Some({
3210									struct DeserializeWith(Vec<EmailProperty>);
3211									impl<'de> Deserialize<'de> for DeserializeWith {
3212										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3213										where
3214											D: Deserializer<'de>,
3215										{
3216											Ok(DeserializeWith(serde_with::As::<
3217												serde_with::OneOrMany<serde_with::Same>,
3218											>::deserialize(deserializer)?))
3219										}
3220									}
3221									match map.next_value::<DeserializeWith>() {
3222										Ok(deserialize_with) => deserialize_with.0,
3223										Err(err) => {
3224											return Err(err);
3225										}
3226									}
3227								});
3228							}
3229							Field::FamilyName => {
3230								if r#family_name_property.is_some() {
3231									return Err(<A::Error as de::Error>::duplicate_field(
3232										"familyName",
3233									));
3234								}
3235								r#family_name_property = Some({
3236									struct DeserializeWith(Vec<FamilyNameProperty>);
3237									impl<'de> Deserialize<'de> for DeserializeWith {
3238										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3239										where
3240											D: Deserializer<'de>,
3241										{
3242											Ok(DeserializeWith(serde_with::As::<
3243												serde_with::OneOrMany<serde_with::Same>,
3244											>::deserialize(deserializer)?))
3245										}
3246									}
3247									match map.next_value::<DeserializeWith>() {
3248										Ok(deserialize_with) => deserialize_with.0,
3249										Err(err) => {
3250											return Err(err);
3251										}
3252									}
3253								});
3254							}
3255							Field::FaxNumber => {
3256								if r#fax_number_property.is_some() {
3257									return Err(<A::Error as de::Error>::duplicate_field(
3258										"faxNumber",
3259									));
3260								}
3261								r#fax_number_property = Some({
3262									struct DeserializeWith(Vec<FaxNumberProperty>);
3263									impl<'de> Deserialize<'de> for DeserializeWith {
3264										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3265										where
3266											D: Deserializer<'de>,
3267										{
3268											Ok(DeserializeWith(serde_with::As::<
3269												serde_with::OneOrMany<serde_with::Same>,
3270											>::deserialize(deserializer)?))
3271										}
3272									}
3273									match map.next_value::<DeserializeWith>() {
3274										Ok(deserialize_with) => deserialize_with.0,
3275										Err(err) => {
3276											return Err(err);
3277										}
3278									}
3279								});
3280							}
3281							Field::Follows => {
3282								if r#follows_property.is_some() {
3283									return Err(<A::Error as de::Error>::duplicate_field(
3284										"follows",
3285									));
3286								}
3287								r#follows_property = Some({
3288									struct DeserializeWith(Vec<FollowsProperty>);
3289									impl<'de> Deserialize<'de> for DeserializeWith {
3290										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3291										where
3292											D: Deserializer<'de>,
3293										{
3294											Ok(DeserializeWith(serde_with::As::<
3295												serde_with::OneOrMany<serde_with::Same>,
3296											>::deserialize(deserializer)?))
3297										}
3298									}
3299									match map.next_value::<DeserializeWith>() {
3300										Ok(deserialize_with) => deserialize_with.0,
3301										Err(err) => {
3302											return Err(err);
3303										}
3304									}
3305								});
3306							}
3307							Field::Funder => {
3308								if r#funder_property.is_some() {
3309									return Err(<A::Error as de::Error>::duplicate_field("funder"));
3310								}
3311								r#funder_property = Some({
3312									struct DeserializeWith(Vec<FunderProperty>);
3313									impl<'de> Deserialize<'de> for DeserializeWith {
3314										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3315										where
3316											D: Deserializer<'de>,
3317										{
3318											Ok(DeserializeWith(serde_with::As::<
3319												serde_with::OneOrMany<serde_with::Same>,
3320											>::deserialize(deserializer)?))
3321										}
3322									}
3323									match map.next_value::<DeserializeWith>() {
3324										Ok(deserialize_with) => deserialize_with.0,
3325										Err(err) => {
3326											return Err(err);
3327										}
3328									}
3329								});
3330							}
3331							Field::Funding => {
3332								if r#funding_property.is_some() {
3333									return Err(<A::Error as de::Error>::duplicate_field(
3334										"funding",
3335									));
3336								}
3337								r#funding_property = Some({
3338									struct DeserializeWith(Vec<FundingProperty>);
3339									impl<'de> Deserialize<'de> for DeserializeWith {
3340										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3341										where
3342											D: Deserializer<'de>,
3343										{
3344											Ok(DeserializeWith(serde_with::As::<
3345												serde_with::OneOrMany<serde_with::Same>,
3346											>::deserialize(deserializer)?))
3347										}
3348									}
3349									match map.next_value::<DeserializeWith>() {
3350										Ok(deserialize_with) => deserialize_with.0,
3351										Err(err) => {
3352											return Err(err);
3353										}
3354									}
3355								});
3356							}
3357							Field::Gender => {
3358								if r#gender_property.is_some() {
3359									return Err(<A::Error as de::Error>::duplicate_field("gender"));
3360								}
3361								r#gender_property = Some({
3362									struct DeserializeWith(Vec<GenderProperty>);
3363									impl<'de> Deserialize<'de> for DeserializeWith {
3364										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3365										where
3366											D: Deserializer<'de>,
3367										{
3368											Ok(DeserializeWith(serde_with::As::<
3369												serde_with::OneOrMany<serde_with::Same>,
3370											>::deserialize(deserializer)?))
3371										}
3372									}
3373									match map.next_value::<DeserializeWith>() {
3374										Ok(deserialize_with) => deserialize_with.0,
3375										Err(err) => {
3376											return Err(err);
3377										}
3378									}
3379								});
3380							}
3381							Field::GivenName => {
3382								if r#given_name_property.is_some() {
3383									return Err(<A::Error as de::Error>::duplicate_field(
3384										"givenName",
3385									));
3386								}
3387								r#given_name_property = Some({
3388									struct DeserializeWith(Vec<GivenNameProperty>);
3389									impl<'de> Deserialize<'de> for DeserializeWith {
3390										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3391										where
3392											D: Deserializer<'de>,
3393										{
3394											Ok(DeserializeWith(serde_with::As::<
3395												serde_with::OneOrMany<serde_with::Same>,
3396											>::deserialize(deserializer)?))
3397										}
3398									}
3399									match map.next_value::<DeserializeWith>() {
3400										Ok(deserialize_with) => deserialize_with.0,
3401										Err(err) => {
3402											return Err(err);
3403										}
3404									}
3405								});
3406							}
3407							Field::GlobalLocationNumber => {
3408								if r#global_location_number_property.is_some() {
3409									return Err(<A::Error as de::Error>::duplicate_field(
3410										"globalLocationNumber",
3411									));
3412								}
3413								r#global_location_number_property = Some({
3414									struct DeserializeWith(Vec<GlobalLocationNumberProperty>);
3415									impl<'de> Deserialize<'de> for DeserializeWith {
3416										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3417										where
3418											D: Deserializer<'de>,
3419										{
3420											Ok(DeserializeWith(serde_with::As::<
3421												serde_with::OneOrMany<serde_with::Same>,
3422											>::deserialize(deserializer)?))
3423										}
3424									}
3425									match map.next_value::<DeserializeWith>() {
3426										Ok(deserialize_with) => deserialize_with.0,
3427										Err(err) => {
3428											return Err(err);
3429										}
3430									}
3431								});
3432							}
3433							Field::HasCredential => {
3434								if r#has_credential_property.is_some() {
3435									return Err(<A::Error as de::Error>::duplicate_field(
3436										"hasCredential",
3437									));
3438								}
3439								r#has_credential_property = Some({
3440									struct DeserializeWith(Vec<HasCredentialProperty>);
3441									impl<'de> Deserialize<'de> for DeserializeWith {
3442										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3443										where
3444											D: Deserializer<'de>,
3445										{
3446											Ok(DeserializeWith(serde_with::As::<
3447												serde_with::OneOrMany<serde_with::Same>,
3448											>::deserialize(deserializer)?))
3449										}
3450									}
3451									match map.next_value::<DeserializeWith>() {
3452										Ok(deserialize_with) => deserialize_with.0,
3453										Err(err) => {
3454											return Err(err);
3455										}
3456									}
3457								});
3458							}
3459							Field::HasOccupation => {
3460								if r#has_occupation_property.is_some() {
3461									return Err(<A::Error as de::Error>::duplicate_field(
3462										"hasOccupation",
3463									));
3464								}
3465								r#has_occupation_property = Some({
3466									struct DeserializeWith(Vec<HasOccupationProperty>);
3467									impl<'de> Deserialize<'de> for DeserializeWith {
3468										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3469										where
3470											D: Deserializer<'de>,
3471										{
3472											Ok(DeserializeWith(serde_with::As::<
3473												serde_with::OneOrMany<serde_with::Same>,
3474											>::deserialize(deserializer)?))
3475										}
3476									}
3477									match map.next_value::<DeserializeWith>() {
3478										Ok(deserialize_with) => deserialize_with.0,
3479										Err(err) => {
3480											return Err(err);
3481										}
3482									}
3483								});
3484							}
3485							Field::HasOfferCatalog => {
3486								if r#has_offer_catalog_property.is_some() {
3487									return Err(<A::Error as de::Error>::duplicate_field(
3488										"hasOfferCatalog",
3489									));
3490								}
3491								r#has_offer_catalog_property = Some({
3492									struct DeserializeWith(Vec<HasOfferCatalogProperty>);
3493									impl<'de> Deserialize<'de> for DeserializeWith {
3494										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3495										where
3496											D: Deserializer<'de>,
3497										{
3498											Ok(DeserializeWith(serde_with::As::<
3499												serde_with::OneOrMany<serde_with::Same>,
3500											>::deserialize(deserializer)?))
3501										}
3502									}
3503									match map.next_value::<DeserializeWith>() {
3504										Ok(deserialize_with) => deserialize_with.0,
3505										Err(err) => {
3506											return Err(err);
3507										}
3508									}
3509								});
3510							}
3511							Field::HasPos => {
3512								if r#has_pos_property.is_some() {
3513									return Err(<A::Error as de::Error>::duplicate_field("hasPOS"));
3514								}
3515								r#has_pos_property = Some({
3516									struct DeserializeWith(Vec<HasPosProperty>);
3517									impl<'de> Deserialize<'de> for DeserializeWith {
3518										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3519										where
3520											D: Deserializer<'de>,
3521										{
3522											Ok(DeserializeWith(serde_with::As::<
3523												serde_with::OneOrMany<serde_with::Same>,
3524											>::deserialize(deserializer)?))
3525										}
3526									}
3527									match map.next_value::<DeserializeWith>() {
3528										Ok(deserialize_with) => deserialize_with.0,
3529										Err(err) => {
3530											return Err(err);
3531										}
3532									}
3533								});
3534							}
3535							Field::Height => {
3536								if r#height_property.is_some() {
3537									return Err(<A::Error as de::Error>::duplicate_field("height"));
3538								}
3539								r#height_property = Some({
3540									struct DeserializeWith(Vec<HeightProperty>);
3541									impl<'de> Deserialize<'de> for DeserializeWith {
3542										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3543										where
3544											D: Deserializer<'de>,
3545										{
3546											Ok(DeserializeWith(serde_with::As::<
3547												serde_with::OneOrMany<serde_with::Same>,
3548											>::deserialize(deserializer)?))
3549										}
3550									}
3551									match map.next_value::<DeserializeWith>() {
3552										Ok(deserialize_with) => deserialize_with.0,
3553										Err(err) => {
3554											return Err(err);
3555										}
3556									}
3557								});
3558							}
3559							Field::HomeLocation => {
3560								if r#home_location_property.is_some() {
3561									return Err(<A::Error as de::Error>::duplicate_field(
3562										"homeLocation",
3563									));
3564								}
3565								r#home_location_property = Some({
3566									struct DeserializeWith(Vec<HomeLocationProperty>);
3567									impl<'de> Deserialize<'de> for DeserializeWith {
3568										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3569										where
3570											D: Deserializer<'de>,
3571										{
3572											Ok(DeserializeWith(serde_with::As::<
3573												serde_with::OneOrMany<serde_with::Same>,
3574											>::deserialize(deserializer)?))
3575										}
3576									}
3577									match map.next_value::<DeserializeWith>() {
3578										Ok(deserialize_with) => deserialize_with.0,
3579										Err(err) => {
3580											return Err(err);
3581										}
3582									}
3583								});
3584							}
3585							Field::HonorificPrefix => {
3586								if r#honorific_prefix_property.is_some() {
3587									return Err(<A::Error as de::Error>::duplicate_field(
3588										"honorificPrefix",
3589									));
3590								}
3591								r#honorific_prefix_property = Some({
3592									struct DeserializeWith(Vec<HonorificPrefixProperty>);
3593									impl<'de> Deserialize<'de> for DeserializeWith {
3594										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3595										where
3596											D: Deserializer<'de>,
3597										{
3598											Ok(DeserializeWith(serde_with::As::<
3599												serde_with::OneOrMany<serde_with::Same>,
3600											>::deserialize(deserializer)?))
3601										}
3602									}
3603									match map.next_value::<DeserializeWith>() {
3604										Ok(deserialize_with) => deserialize_with.0,
3605										Err(err) => {
3606											return Err(err);
3607										}
3608									}
3609								});
3610							}
3611							Field::HonorificSuffix => {
3612								if r#honorific_suffix_property.is_some() {
3613									return Err(<A::Error as de::Error>::duplicate_field(
3614										"honorificSuffix",
3615									));
3616								}
3617								r#honorific_suffix_property = Some({
3618									struct DeserializeWith(Vec<HonorificSuffixProperty>);
3619									impl<'de> Deserialize<'de> for DeserializeWith {
3620										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3621										where
3622											D: Deserializer<'de>,
3623										{
3624											Ok(DeserializeWith(serde_with::As::<
3625												serde_with::OneOrMany<serde_with::Same>,
3626											>::deserialize(deserializer)?))
3627										}
3628									}
3629									match map.next_value::<DeserializeWith>() {
3630										Ok(deserialize_with) => deserialize_with.0,
3631										Err(err) => {
3632											return Err(err);
3633										}
3634									}
3635								});
3636							}
3637							Field::InteractionStatistic => {
3638								if r#interaction_statistic_property.is_some() {
3639									return Err(<A::Error as de::Error>::duplicate_field(
3640										"interactionStatistic",
3641									));
3642								}
3643								r#interaction_statistic_property = Some({
3644									struct DeserializeWith(Vec<InteractionStatisticProperty>);
3645									impl<'de> Deserialize<'de> for DeserializeWith {
3646										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3647										where
3648											D: Deserializer<'de>,
3649										{
3650											Ok(DeserializeWith(serde_with::As::<
3651												serde_with::OneOrMany<serde_with::Same>,
3652											>::deserialize(deserializer)?))
3653										}
3654									}
3655									match map.next_value::<DeserializeWith>() {
3656										Ok(deserialize_with) => deserialize_with.0,
3657										Err(err) => {
3658											return Err(err);
3659										}
3660									}
3661								});
3662							}
3663							Field::IsicV4 => {
3664								if r#isic_v_4_property.is_some() {
3665									return Err(<A::Error as de::Error>::duplicate_field("isicV4"));
3666								}
3667								r#isic_v_4_property = Some({
3668									struct DeserializeWith(Vec<IsicV4Property>);
3669									impl<'de> Deserialize<'de> for DeserializeWith {
3670										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3671										where
3672											D: Deserializer<'de>,
3673										{
3674											Ok(DeserializeWith(serde_with::As::<
3675												serde_with::OneOrMany<serde_with::Same>,
3676											>::deserialize(deserializer)?))
3677										}
3678									}
3679									match map.next_value::<DeserializeWith>() {
3680										Ok(deserialize_with) => deserialize_with.0,
3681										Err(err) => {
3682											return Err(err);
3683										}
3684									}
3685								});
3686							}
3687							Field::JobTitle => {
3688								if r#job_title_property.is_some() {
3689									return Err(<A::Error as de::Error>::duplicate_field(
3690										"jobTitle",
3691									));
3692								}
3693								r#job_title_property = Some({
3694									struct DeserializeWith(Vec<JobTitleProperty>);
3695									impl<'de> Deserialize<'de> for DeserializeWith {
3696										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3697										where
3698											D: Deserializer<'de>,
3699										{
3700											Ok(DeserializeWith(serde_with::As::<
3701												serde_with::OneOrMany<serde_with::Same>,
3702											>::deserialize(deserializer)?))
3703										}
3704									}
3705									match map.next_value::<DeserializeWith>() {
3706										Ok(deserialize_with) => deserialize_with.0,
3707										Err(err) => {
3708											return Err(err);
3709										}
3710									}
3711								});
3712							}
3713							Field::Knows => {
3714								if r#knows_property.is_some() {
3715									return Err(<A::Error as de::Error>::duplicate_field("knows"));
3716								}
3717								r#knows_property = Some({
3718									struct DeserializeWith(Vec<KnowsProperty>);
3719									impl<'de> Deserialize<'de> for DeserializeWith {
3720										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3721										where
3722											D: Deserializer<'de>,
3723										{
3724											Ok(DeserializeWith(serde_with::As::<
3725												serde_with::OneOrMany<serde_with::Same>,
3726											>::deserialize(deserializer)?))
3727										}
3728									}
3729									match map.next_value::<DeserializeWith>() {
3730										Ok(deserialize_with) => deserialize_with.0,
3731										Err(err) => {
3732											return Err(err);
3733										}
3734									}
3735								});
3736							}
3737							Field::KnowsAbout => {
3738								if r#knows_about_property.is_some() {
3739									return Err(<A::Error as de::Error>::duplicate_field(
3740										"knowsAbout",
3741									));
3742								}
3743								r#knows_about_property = Some({
3744									struct DeserializeWith(Vec<KnowsAboutProperty>);
3745									impl<'de> Deserialize<'de> for DeserializeWith {
3746										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3747										where
3748											D: Deserializer<'de>,
3749										{
3750											Ok(DeserializeWith(serde_with::As::<
3751												serde_with::OneOrMany<serde_with::Same>,
3752											>::deserialize(deserializer)?))
3753										}
3754									}
3755									match map.next_value::<DeserializeWith>() {
3756										Ok(deserialize_with) => deserialize_with.0,
3757										Err(err) => {
3758											return Err(err);
3759										}
3760									}
3761								});
3762							}
3763							Field::KnowsLanguage => {
3764								if r#knows_language_property.is_some() {
3765									return Err(<A::Error as de::Error>::duplicate_field(
3766										"knowsLanguage",
3767									));
3768								}
3769								r#knows_language_property = Some({
3770									struct DeserializeWith(Vec<KnowsLanguageProperty>);
3771									impl<'de> Deserialize<'de> for DeserializeWith {
3772										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3773										where
3774											D: Deserializer<'de>,
3775										{
3776											Ok(DeserializeWith(serde_with::As::<
3777												serde_with::OneOrMany<serde_with::Same>,
3778											>::deserialize(deserializer)?))
3779										}
3780									}
3781									match map.next_value::<DeserializeWith>() {
3782										Ok(deserialize_with) => deserialize_with.0,
3783										Err(err) => {
3784											return Err(err);
3785										}
3786									}
3787								});
3788							}
3789							Field::MakesOffer => {
3790								if r#makes_offer_property.is_some() {
3791									return Err(<A::Error as de::Error>::duplicate_field(
3792										"makesOffer",
3793									));
3794								}
3795								r#makes_offer_property = Some({
3796									struct DeserializeWith(Vec<MakesOfferProperty>);
3797									impl<'de> Deserialize<'de> for DeserializeWith {
3798										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3799										where
3800											D: Deserializer<'de>,
3801										{
3802											Ok(DeserializeWith(serde_with::As::<
3803												serde_with::OneOrMany<serde_with::Same>,
3804											>::deserialize(deserializer)?))
3805										}
3806									}
3807									match map.next_value::<DeserializeWith>() {
3808										Ok(deserialize_with) => deserialize_with.0,
3809										Err(err) => {
3810											return Err(err);
3811										}
3812									}
3813								});
3814							}
3815							Field::MemberOf => {
3816								if r#member_of_property.is_some() {
3817									return Err(<A::Error as de::Error>::duplicate_field(
3818										"memberOf",
3819									));
3820								}
3821								r#member_of_property = Some({
3822									struct DeserializeWith(Vec<MemberOfProperty>);
3823									impl<'de> Deserialize<'de> for DeserializeWith {
3824										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3825										where
3826											D: Deserializer<'de>,
3827										{
3828											Ok(DeserializeWith(serde_with::As::<
3829												serde_with::OneOrMany<serde_with::Same>,
3830											>::deserialize(deserializer)?))
3831										}
3832									}
3833									match map.next_value::<DeserializeWith>() {
3834										Ok(deserialize_with) => deserialize_with.0,
3835										Err(err) => {
3836											return Err(err);
3837										}
3838									}
3839								});
3840							}
3841							Field::Naics => {
3842								if r#naics_property.is_some() {
3843									return Err(<A::Error as de::Error>::duplicate_field("naics"));
3844								}
3845								r#naics_property = Some({
3846									struct DeserializeWith(Vec<NaicsProperty>);
3847									impl<'de> Deserialize<'de> for DeserializeWith {
3848										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3849										where
3850											D: Deserializer<'de>,
3851										{
3852											Ok(DeserializeWith(serde_with::As::<
3853												serde_with::OneOrMany<serde_with::Same>,
3854											>::deserialize(deserializer)?))
3855										}
3856									}
3857									match map.next_value::<DeserializeWith>() {
3858										Ok(deserialize_with) => deserialize_with.0,
3859										Err(err) => {
3860											return Err(err);
3861										}
3862									}
3863								});
3864							}
3865							Field::Nationality => {
3866								if r#nationality_property.is_some() {
3867									return Err(<A::Error as de::Error>::duplicate_field(
3868										"nationality",
3869									));
3870								}
3871								r#nationality_property = Some({
3872									struct DeserializeWith(Vec<NationalityProperty>);
3873									impl<'de> Deserialize<'de> for DeserializeWith {
3874										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3875										where
3876											D: Deserializer<'de>,
3877										{
3878											Ok(DeserializeWith(serde_with::As::<
3879												serde_with::OneOrMany<serde_with::Same>,
3880											>::deserialize(deserializer)?))
3881										}
3882									}
3883									match map.next_value::<DeserializeWith>() {
3884										Ok(deserialize_with) => deserialize_with.0,
3885										Err(err) => {
3886											return Err(err);
3887										}
3888									}
3889								});
3890							}
3891							Field::NetWorth => {
3892								if r#net_worth_property.is_some() {
3893									return Err(<A::Error as de::Error>::duplicate_field(
3894										"netWorth",
3895									));
3896								}
3897								r#net_worth_property = Some({
3898									struct DeserializeWith(Vec<NetWorthProperty>);
3899									impl<'de> Deserialize<'de> for DeserializeWith {
3900										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3901										where
3902											D: Deserializer<'de>,
3903										{
3904											Ok(DeserializeWith(serde_with::As::<
3905												serde_with::OneOrMany<serde_with::Same>,
3906											>::deserialize(deserializer)?))
3907										}
3908									}
3909									match map.next_value::<DeserializeWith>() {
3910										Ok(deserialize_with) => deserialize_with.0,
3911										Err(err) => {
3912											return Err(err);
3913										}
3914									}
3915								});
3916							}
3917							Field::Owns => {
3918								if r#owns_property.is_some() {
3919									return Err(<A::Error as de::Error>::duplicate_field("owns"));
3920								}
3921								r#owns_property = Some({
3922									struct DeserializeWith(Vec<OwnsProperty>);
3923									impl<'de> Deserialize<'de> for DeserializeWith {
3924										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3925										where
3926											D: Deserializer<'de>,
3927										{
3928											Ok(DeserializeWith(serde_with::As::<
3929												serde_with::OneOrMany<serde_with::Same>,
3930											>::deserialize(deserializer)?))
3931										}
3932									}
3933									match map.next_value::<DeserializeWith>() {
3934										Ok(deserialize_with) => deserialize_with.0,
3935										Err(err) => {
3936											return Err(err);
3937										}
3938									}
3939								});
3940							}
3941							Field::Parent => {
3942								if r#parent_property.is_some() {
3943									return Err(<A::Error as de::Error>::duplicate_field("parent"));
3944								}
3945								r#parent_property = Some({
3946									struct DeserializeWith(Vec<ParentProperty>);
3947									impl<'de> Deserialize<'de> for DeserializeWith {
3948										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3949										where
3950											D: Deserializer<'de>,
3951										{
3952											Ok(DeserializeWith(serde_with::As::<
3953												serde_with::OneOrMany<serde_with::Same>,
3954											>::deserialize(deserializer)?))
3955										}
3956									}
3957									match map.next_value::<DeserializeWith>() {
3958										Ok(deserialize_with) => deserialize_with.0,
3959										Err(err) => {
3960											return Err(err);
3961										}
3962									}
3963								});
3964							}
3965							Field::Parents => {
3966								if r#parents_property.is_some() {
3967									return Err(<A::Error as de::Error>::duplicate_field(
3968										"parents",
3969									));
3970								}
3971								r#parents_property = Some({
3972									struct DeserializeWith(Vec<ParentsProperty>);
3973									impl<'de> Deserialize<'de> for DeserializeWith {
3974										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3975										where
3976											D: Deserializer<'de>,
3977										{
3978											Ok(DeserializeWith(serde_with::As::<
3979												serde_with::OneOrMany<serde_with::Same>,
3980											>::deserialize(deserializer)?))
3981										}
3982									}
3983									match map.next_value::<DeserializeWith>() {
3984										Ok(deserialize_with) => deserialize_with.0,
3985										Err(err) => {
3986											return Err(err);
3987										}
3988									}
3989								});
3990							}
3991							Field::PerformerIn => {
3992								if r#performer_in_property.is_some() {
3993									return Err(<A::Error as de::Error>::duplicate_field(
3994										"performerIn",
3995									));
3996								}
3997								r#performer_in_property = Some({
3998									struct DeserializeWith(Vec<PerformerInProperty>);
3999									impl<'de> Deserialize<'de> for DeserializeWith {
4000										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4001										where
4002											D: Deserializer<'de>,
4003										{
4004											Ok(DeserializeWith(serde_with::As::<
4005												serde_with::OneOrMany<serde_with::Same>,
4006											>::deserialize(deserializer)?))
4007										}
4008									}
4009									match map.next_value::<DeserializeWith>() {
4010										Ok(deserialize_with) => deserialize_with.0,
4011										Err(err) => {
4012											return Err(err);
4013										}
4014									}
4015								});
4016							}
4017							Field::PublishingPrinciples => {
4018								if r#publishing_principles_property.is_some() {
4019									return Err(<A::Error as de::Error>::duplicate_field(
4020										"publishingPrinciples",
4021									));
4022								}
4023								r#publishing_principles_property = Some({
4024									struct DeserializeWith(Vec<PublishingPrinciplesProperty>);
4025									impl<'de> Deserialize<'de> for DeserializeWith {
4026										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4027										where
4028											D: Deserializer<'de>,
4029										{
4030											Ok(DeserializeWith(serde_with::As::<
4031												serde_with::OneOrMany<serde_with::Same>,
4032											>::deserialize(deserializer)?))
4033										}
4034									}
4035									match map.next_value::<DeserializeWith>() {
4036										Ok(deserialize_with) => deserialize_with.0,
4037										Err(err) => {
4038											return Err(err);
4039										}
4040									}
4041								});
4042							}
4043							Field::RelatedTo => {
4044								if r#related_to_property.is_some() {
4045									return Err(<A::Error as de::Error>::duplicate_field(
4046										"relatedTo",
4047									));
4048								}
4049								r#related_to_property = Some({
4050									struct DeserializeWith(Vec<RelatedToProperty>);
4051									impl<'de> Deserialize<'de> for DeserializeWith {
4052										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4053										where
4054											D: Deserializer<'de>,
4055										{
4056											Ok(DeserializeWith(serde_with::As::<
4057												serde_with::OneOrMany<serde_with::Same>,
4058											>::deserialize(deserializer)?))
4059										}
4060									}
4061									match map.next_value::<DeserializeWith>() {
4062										Ok(deserialize_with) => deserialize_with.0,
4063										Err(err) => {
4064											return Err(err);
4065										}
4066									}
4067								});
4068							}
4069							Field::Seeks => {
4070								if r#seeks_property.is_some() {
4071									return Err(<A::Error as de::Error>::duplicate_field("seeks"));
4072								}
4073								r#seeks_property = Some({
4074									struct DeserializeWith(Vec<SeeksProperty>);
4075									impl<'de> Deserialize<'de> for DeserializeWith {
4076										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4077										where
4078											D: Deserializer<'de>,
4079										{
4080											Ok(DeserializeWith(serde_with::As::<
4081												serde_with::OneOrMany<serde_with::Same>,
4082											>::deserialize(deserializer)?))
4083										}
4084									}
4085									match map.next_value::<DeserializeWith>() {
4086										Ok(deserialize_with) => deserialize_with.0,
4087										Err(err) => {
4088											return Err(err);
4089										}
4090									}
4091								});
4092							}
4093							Field::Sibling => {
4094								if r#sibling_property.is_some() {
4095									return Err(<A::Error as de::Error>::duplicate_field(
4096										"sibling",
4097									));
4098								}
4099								r#sibling_property = Some({
4100									struct DeserializeWith(Vec<SiblingProperty>);
4101									impl<'de> Deserialize<'de> for DeserializeWith {
4102										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4103										where
4104											D: Deserializer<'de>,
4105										{
4106											Ok(DeserializeWith(serde_with::As::<
4107												serde_with::OneOrMany<serde_with::Same>,
4108											>::deserialize(deserializer)?))
4109										}
4110									}
4111									match map.next_value::<DeserializeWith>() {
4112										Ok(deserialize_with) => deserialize_with.0,
4113										Err(err) => {
4114											return Err(err);
4115										}
4116									}
4117								});
4118							}
4119							Field::Siblings => {
4120								if r#siblings_property.is_some() {
4121									return Err(<A::Error as de::Error>::duplicate_field(
4122										"siblings",
4123									));
4124								}
4125								r#siblings_property = Some({
4126									struct DeserializeWith(Vec<SiblingsProperty>);
4127									impl<'de> Deserialize<'de> for DeserializeWith {
4128										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4129										where
4130											D: Deserializer<'de>,
4131										{
4132											Ok(DeserializeWith(serde_with::As::<
4133												serde_with::OneOrMany<serde_with::Same>,
4134											>::deserialize(deserializer)?))
4135										}
4136									}
4137									match map.next_value::<DeserializeWith>() {
4138										Ok(deserialize_with) => deserialize_with.0,
4139										Err(err) => {
4140											return Err(err);
4141										}
4142									}
4143								});
4144							}
4145							Field::Sponsor => {
4146								if r#sponsor_property.is_some() {
4147									return Err(<A::Error as de::Error>::duplicate_field(
4148										"sponsor",
4149									));
4150								}
4151								r#sponsor_property = Some({
4152									struct DeserializeWith(Vec<SponsorProperty>);
4153									impl<'de> Deserialize<'de> for DeserializeWith {
4154										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4155										where
4156											D: Deserializer<'de>,
4157										{
4158											Ok(DeserializeWith(serde_with::As::<
4159												serde_with::OneOrMany<serde_with::Same>,
4160											>::deserialize(deserializer)?))
4161										}
4162									}
4163									match map.next_value::<DeserializeWith>() {
4164										Ok(deserialize_with) => deserialize_with.0,
4165										Err(err) => {
4166											return Err(err);
4167										}
4168									}
4169								});
4170							}
4171							Field::Spouse => {
4172								if r#spouse_property.is_some() {
4173									return Err(<A::Error as de::Error>::duplicate_field("spouse"));
4174								}
4175								r#spouse_property = Some({
4176									struct DeserializeWith(Vec<SpouseProperty>);
4177									impl<'de> Deserialize<'de> for DeserializeWith {
4178										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4179										where
4180											D: Deserializer<'de>,
4181										{
4182											Ok(DeserializeWith(serde_with::As::<
4183												serde_with::OneOrMany<serde_with::Same>,
4184											>::deserialize(deserializer)?))
4185										}
4186									}
4187									match map.next_value::<DeserializeWith>() {
4188										Ok(deserialize_with) => deserialize_with.0,
4189										Err(err) => {
4190											return Err(err);
4191										}
4192									}
4193								});
4194							}
4195							Field::TaxId => {
4196								if r#tax_id_property.is_some() {
4197									return Err(<A::Error as de::Error>::duplicate_field("taxID"));
4198								}
4199								r#tax_id_property = Some({
4200									struct DeserializeWith(Vec<TaxIdProperty>);
4201									impl<'de> Deserialize<'de> for DeserializeWith {
4202										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4203										where
4204											D: Deserializer<'de>,
4205										{
4206											Ok(DeserializeWith(serde_with::As::<
4207												serde_with::OneOrMany<serde_with::Same>,
4208											>::deserialize(deserializer)?))
4209										}
4210									}
4211									match map.next_value::<DeserializeWith>() {
4212										Ok(deserialize_with) => deserialize_with.0,
4213										Err(err) => {
4214											return Err(err);
4215										}
4216									}
4217								});
4218							}
4219							Field::Telephone => {
4220								if r#telephone_property.is_some() {
4221									return Err(<A::Error as de::Error>::duplicate_field(
4222										"telephone",
4223									));
4224								}
4225								r#telephone_property = Some({
4226									struct DeserializeWith(Vec<TelephoneProperty>);
4227									impl<'de> Deserialize<'de> for DeserializeWith {
4228										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4229										where
4230											D: Deserializer<'de>,
4231										{
4232											Ok(DeserializeWith(serde_with::As::<
4233												serde_with::OneOrMany<serde_with::Same>,
4234											>::deserialize(deserializer)?))
4235										}
4236									}
4237									match map.next_value::<DeserializeWith>() {
4238										Ok(deserialize_with) => deserialize_with.0,
4239										Err(err) => {
4240											return Err(err);
4241										}
4242									}
4243								});
4244							}
4245							Field::VatId => {
4246								if r#vat_id_property.is_some() {
4247									return Err(<A::Error as de::Error>::duplicate_field("vatID"));
4248								}
4249								r#vat_id_property = Some({
4250									struct DeserializeWith(Vec<VatIdProperty>);
4251									impl<'de> Deserialize<'de> for DeserializeWith {
4252										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4253										where
4254											D: Deserializer<'de>,
4255										{
4256											Ok(DeserializeWith(serde_with::As::<
4257												serde_with::OneOrMany<serde_with::Same>,
4258											>::deserialize(deserializer)?))
4259										}
4260									}
4261									match map.next_value::<DeserializeWith>() {
4262										Ok(deserialize_with) => deserialize_with.0,
4263										Err(err) => {
4264											return Err(err);
4265										}
4266									}
4267								});
4268							}
4269							Field::Weight => {
4270								if r#weight_property.is_some() {
4271									return Err(<A::Error as de::Error>::duplicate_field("weight"));
4272								}
4273								r#weight_property = Some({
4274									struct DeserializeWith(Vec<WeightProperty>);
4275									impl<'de> Deserialize<'de> for DeserializeWith {
4276										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4277										where
4278											D: Deserializer<'de>,
4279										{
4280											Ok(DeserializeWith(serde_with::As::<
4281												serde_with::OneOrMany<serde_with::Same>,
4282											>::deserialize(deserializer)?))
4283										}
4284									}
4285									match map.next_value::<DeserializeWith>() {
4286										Ok(deserialize_with) => deserialize_with.0,
4287										Err(err) => {
4288											return Err(err);
4289										}
4290									}
4291								});
4292							}
4293							Field::WorkLocation => {
4294								if r#work_location_property.is_some() {
4295									return Err(<A::Error as de::Error>::duplicate_field(
4296										"workLocation",
4297									));
4298								}
4299								r#work_location_property = Some({
4300									struct DeserializeWith(Vec<WorkLocationProperty>);
4301									impl<'de> Deserialize<'de> for DeserializeWith {
4302										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4303										where
4304											D: Deserializer<'de>,
4305										{
4306											Ok(DeserializeWith(serde_with::As::<
4307												serde_with::OneOrMany<serde_with::Same>,
4308											>::deserialize(deserializer)?))
4309										}
4310									}
4311									match map.next_value::<DeserializeWith>() {
4312										Ok(deserialize_with) => deserialize_with.0,
4313										Err(err) => {
4314											return Err(err);
4315										}
4316									}
4317								});
4318							}
4319							Field::WorksFor => {
4320								if r#works_for_property.is_some() {
4321									return Err(<A::Error as de::Error>::duplicate_field(
4322										"worksFor",
4323									));
4324								}
4325								r#works_for_property = Some({
4326									struct DeserializeWith(Vec<WorksForProperty>);
4327									impl<'de> Deserialize<'de> for DeserializeWith {
4328										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4329										where
4330											D: Deserializer<'de>,
4331										{
4332											Ok(DeserializeWith(serde_with::As::<
4333												serde_with::OneOrMany<serde_with::Same>,
4334											>::deserialize(deserializer)?))
4335										}
4336									}
4337									match map.next_value::<DeserializeWith>() {
4338										Ok(deserialize_with) => deserialize_with.0,
4339										Err(err) => {
4340											return Err(err);
4341										}
4342									}
4343								});
4344							}
4345							Field::AdditionalType => {
4346								if r#additional_type_property.is_some() {
4347									return Err(<A::Error as de::Error>::duplicate_field(
4348										"additionalType",
4349									));
4350								}
4351								r#additional_type_property = Some({
4352									struct DeserializeWith(Vec<AdditionalTypeProperty>);
4353									impl<'de> Deserialize<'de> for DeserializeWith {
4354										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4355										where
4356											D: Deserializer<'de>,
4357										{
4358											Ok(DeserializeWith(serde_with::As::<
4359												serde_with::OneOrMany<serde_with::Same>,
4360											>::deserialize(deserializer)?))
4361										}
4362									}
4363									match map.next_value::<DeserializeWith>() {
4364										Ok(deserialize_with) => deserialize_with.0,
4365										Err(err) => {
4366											return Err(err);
4367										}
4368									}
4369								});
4370							}
4371							Field::AlternateName => {
4372								if r#alternate_name_property.is_some() {
4373									return Err(<A::Error as de::Error>::duplicate_field(
4374										"alternateName",
4375									));
4376								}
4377								r#alternate_name_property = Some({
4378									struct DeserializeWith(Vec<AlternateNameProperty>);
4379									impl<'de> Deserialize<'de> for DeserializeWith {
4380										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4381										where
4382											D: Deserializer<'de>,
4383										{
4384											Ok(DeserializeWith(serde_with::As::<
4385												serde_with::OneOrMany<serde_with::Same>,
4386											>::deserialize(deserializer)?))
4387										}
4388									}
4389									match map.next_value::<DeserializeWith>() {
4390										Ok(deserialize_with) => deserialize_with.0,
4391										Err(err) => {
4392											return Err(err);
4393										}
4394									}
4395								});
4396							}
4397							Field::Description => {
4398								if r#description_property.is_some() {
4399									return Err(<A::Error as de::Error>::duplicate_field(
4400										"description",
4401									));
4402								}
4403								r#description_property = Some({
4404									struct DeserializeWith(Vec<DescriptionProperty>);
4405									impl<'de> Deserialize<'de> for DeserializeWith {
4406										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4407										where
4408											D: Deserializer<'de>,
4409										{
4410											Ok(DeserializeWith(serde_with::As::<
4411												serde_with::OneOrMany<serde_with::Same>,
4412											>::deserialize(deserializer)?))
4413										}
4414									}
4415									match map.next_value::<DeserializeWith>() {
4416										Ok(deserialize_with) => deserialize_with.0,
4417										Err(err) => {
4418											return Err(err);
4419										}
4420									}
4421								});
4422							}
4423							Field::DisambiguatingDescription => {
4424								if r#disambiguating_description_property.is_some() {
4425									return Err(<A::Error as de::Error>::duplicate_field(
4426										"disambiguatingDescription",
4427									));
4428								}
4429								r#disambiguating_description_property = Some({
4430									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
4431									impl<'de> Deserialize<'de> for DeserializeWith {
4432										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4433										where
4434											D: Deserializer<'de>,
4435										{
4436											Ok(DeserializeWith(serde_with::As::<
4437												serde_with::OneOrMany<serde_with::Same>,
4438											>::deserialize(deserializer)?))
4439										}
4440									}
4441									match map.next_value::<DeserializeWith>() {
4442										Ok(deserialize_with) => deserialize_with.0,
4443										Err(err) => {
4444											return Err(err);
4445										}
4446									}
4447								});
4448							}
4449							Field::Identifier => {
4450								if r#identifier_property.is_some() {
4451									return Err(<A::Error as de::Error>::duplicate_field(
4452										"identifier",
4453									));
4454								}
4455								r#identifier_property = Some({
4456									struct DeserializeWith(Vec<IdentifierProperty>);
4457									impl<'de> Deserialize<'de> for DeserializeWith {
4458										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4459										where
4460											D: Deserializer<'de>,
4461										{
4462											Ok(DeserializeWith(serde_with::As::<
4463												serde_with::OneOrMany<serde_with::Same>,
4464											>::deserialize(deserializer)?))
4465										}
4466									}
4467									match map.next_value::<DeserializeWith>() {
4468										Ok(deserialize_with) => deserialize_with.0,
4469										Err(err) => {
4470											return Err(err);
4471										}
4472									}
4473								});
4474							}
4475							Field::Image => {
4476								if r#image_property.is_some() {
4477									return Err(<A::Error as de::Error>::duplicate_field("image"));
4478								}
4479								r#image_property = Some({
4480									struct DeserializeWith(Vec<ImageProperty>);
4481									impl<'de> Deserialize<'de> for DeserializeWith {
4482										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4483										where
4484											D: Deserializer<'de>,
4485										{
4486											Ok(DeserializeWith(serde_with::As::<
4487												serde_with::OneOrMany<serde_with::Same>,
4488											>::deserialize(deserializer)?))
4489										}
4490									}
4491									match map.next_value::<DeserializeWith>() {
4492										Ok(deserialize_with) => deserialize_with.0,
4493										Err(err) => {
4494											return Err(err);
4495										}
4496									}
4497								});
4498							}
4499							Field::MainEntityOfPage => {
4500								if r#main_entity_of_page_property.is_some() {
4501									return Err(<A::Error as de::Error>::duplicate_field(
4502										"mainEntityOfPage",
4503									));
4504								}
4505								r#main_entity_of_page_property = Some({
4506									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
4507									impl<'de> Deserialize<'de> for DeserializeWith {
4508										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4509										where
4510											D: Deserializer<'de>,
4511										{
4512											Ok(DeserializeWith(serde_with::As::<
4513												serde_with::OneOrMany<serde_with::Same>,
4514											>::deserialize(deserializer)?))
4515										}
4516									}
4517									match map.next_value::<DeserializeWith>() {
4518										Ok(deserialize_with) => deserialize_with.0,
4519										Err(err) => {
4520											return Err(err);
4521										}
4522									}
4523								});
4524							}
4525							Field::Name => {
4526								if r#name_property.is_some() {
4527									return Err(<A::Error as de::Error>::duplicate_field("name"));
4528								}
4529								r#name_property = Some({
4530									struct DeserializeWith(Vec<NameProperty>);
4531									impl<'de> Deserialize<'de> for DeserializeWith {
4532										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4533										where
4534											D: Deserializer<'de>,
4535										{
4536											Ok(DeserializeWith(serde_with::As::<
4537												serde_with::OneOrMany<serde_with::Same>,
4538											>::deserialize(deserializer)?))
4539										}
4540									}
4541									match map.next_value::<DeserializeWith>() {
4542										Ok(deserialize_with) => deserialize_with.0,
4543										Err(err) => {
4544											return Err(err);
4545										}
4546									}
4547								});
4548							}
4549							Field::PotentialAction => {
4550								if r#potential_action_property.is_some() {
4551									return Err(<A::Error as de::Error>::duplicate_field(
4552										"potentialAction",
4553									));
4554								}
4555								r#potential_action_property = Some({
4556									struct DeserializeWith(Vec<PotentialActionProperty>);
4557									impl<'de> Deserialize<'de> for DeserializeWith {
4558										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4559										where
4560											D: Deserializer<'de>,
4561										{
4562											Ok(DeserializeWith(serde_with::As::<
4563												serde_with::OneOrMany<serde_with::Same>,
4564											>::deserialize(deserializer)?))
4565										}
4566									}
4567									match map.next_value::<DeserializeWith>() {
4568										Ok(deserialize_with) => deserialize_with.0,
4569										Err(err) => {
4570											return Err(err);
4571										}
4572									}
4573								});
4574							}
4575							Field::SameAs => {
4576								if r#same_as_property.is_some() {
4577									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
4578								}
4579								r#same_as_property = Some({
4580									struct DeserializeWith(Vec<SameAsProperty>);
4581									impl<'de> Deserialize<'de> for DeserializeWith {
4582										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4583										where
4584											D: Deserializer<'de>,
4585										{
4586											Ok(DeserializeWith(serde_with::As::<
4587												serde_with::OneOrMany<serde_with::Same>,
4588											>::deserialize(deserializer)?))
4589										}
4590									}
4591									match map.next_value::<DeserializeWith>() {
4592										Ok(deserialize_with) => deserialize_with.0,
4593										Err(err) => {
4594											return Err(err);
4595										}
4596									}
4597								});
4598							}
4599							Field::SubjectOf => {
4600								if r#subject_of_property.is_some() {
4601									return Err(<A::Error as de::Error>::duplicate_field(
4602										"subjectOf",
4603									));
4604								}
4605								r#subject_of_property = Some({
4606									struct DeserializeWith(Vec<SubjectOfProperty>);
4607									impl<'de> Deserialize<'de> for DeserializeWith {
4608										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4609										where
4610											D: Deserializer<'de>,
4611										{
4612											Ok(DeserializeWith(serde_with::As::<
4613												serde_with::OneOrMany<serde_with::Same>,
4614											>::deserialize(deserializer)?))
4615										}
4616									}
4617									match map.next_value::<DeserializeWith>() {
4618										Ok(deserialize_with) => deserialize_with.0,
4619										Err(err) => {
4620											return Err(err);
4621										}
4622									}
4623								});
4624							}
4625							Field::Url => {
4626								if r#url_property.is_some() {
4627									return Err(<A::Error as de::Error>::duplicate_field("url"));
4628								}
4629								r#url_property = Some({
4630									struct DeserializeWith(Vec<UrlProperty>);
4631									impl<'de> Deserialize<'de> for DeserializeWith {
4632										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4633										where
4634											D: Deserializer<'de>,
4635										{
4636											Ok(DeserializeWith(serde_with::As::<
4637												serde_with::OneOrMany<serde_with::Same>,
4638											>::deserialize(deserializer)?))
4639										}
4640									}
4641									match map.next_value::<DeserializeWith>() {
4642										Ok(deserialize_with) => deserialize_with.0,
4643										Err(err) => {
4644											return Err(err);
4645										}
4646									}
4647								});
4648							}
4649							Field::Ignore => {
4650								let _ = map.next_value::<de::IgnoredAny>()?;
4651							}
4652						}
4653					}
4654					Ok(Person {
4655						r#additional_name: r#additional_name_property.unwrap_or_default(),
4656						r#address: r#address_property.unwrap_or_default(),
4657						r#affiliation: r#affiliation_property.unwrap_or_default(),
4658						r#agent_interaction_statistic: r#agent_interaction_statistic_property
4659							.unwrap_or_default(),
4660						r#alumni_of: r#alumni_of_property.unwrap_or_default(),
4661						r#award: r#award_property.unwrap_or_default(),
4662						r#awards: r#awards_property.unwrap_or_default(),
4663						r#birth_date: r#birth_date_property.unwrap_or_default(),
4664						r#birth_place: r#birth_place_property.unwrap_or_default(),
4665						r#brand: r#brand_property.unwrap_or_default(),
4666						r#call_sign: r#call_sign_property.unwrap_or_default(),
4667						r#children: r#children_property.unwrap_or_default(),
4668						r#colleague: r#colleague_property.unwrap_or_default(),
4669						r#colleagues: r#colleagues_property.unwrap_or_default(),
4670						r#contact_point: r#contact_point_property.unwrap_or_default(),
4671						r#contact_points: r#contact_points_property.unwrap_or_default(),
4672						r#death_date: r#death_date_property.unwrap_or_default(),
4673						r#death_place: r#death_place_property.unwrap_or_default(),
4674						r#duns: r#duns_property.unwrap_or_default(),
4675						r#email: r#email_property.unwrap_or_default(),
4676						r#family_name: r#family_name_property.unwrap_or_default(),
4677						r#fax_number: r#fax_number_property.unwrap_or_default(),
4678						r#follows: r#follows_property.unwrap_or_default(),
4679						r#funder: r#funder_property.unwrap_or_default(),
4680						r#funding: r#funding_property.unwrap_or_default(),
4681						r#gender: r#gender_property.unwrap_or_default(),
4682						r#given_name: r#given_name_property.unwrap_or_default(),
4683						r#global_location_number: r#global_location_number_property
4684							.unwrap_or_default(),
4685						r#has_credential: r#has_credential_property.unwrap_or_default(),
4686						r#has_occupation: r#has_occupation_property.unwrap_or_default(),
4687						r#has_offer_catalog: r#has_offer_catalog_property.unwrap_or_default(),
4688						r#has_pos: r#has_pos_property.unwrap_or_default(),
4689						r#height: r#height_property.unwrap_or_default(),
4690						r#home_location: r#home_location_property.unwrap_or_default(),
4691						r#honorific_prefix: r#honorific_prefix_property.unwrap_or_default(),
4692						r#honorific_suffix: r#honorific_suffix_property.unwrap_or_default(),
4693						r#interaction_statistic: r#interaction_statistic_property
4694							.unwrap_or_default(),
4695						r#isic_v_4: r#isic_v_4_property.unwrap_or_default(),
4696						r#job_title: r#job_title_property.unwrap_or_default(),
4697						r#knows: r#knows_property.unwrap_or_default(),
4698						r#knows_about: r#knows_about_property.unwrap_or_default(),
4699						r#knows_language: r#knows_language_property.unwrap_or_default(),
4700						r#makes_offer: r#makes_offer_property.unwrap_or_default(),
4701						r#member_of: r#member_of_property.unwrap_or_default(),
4702						r#naics: r#naics_property.unwrap_or_default(),
4703						r#nationality: r#nationality_property.unwrap_or_default(),
4704						r#net_worth: r#net_worth_property.unwrap_or_default(),
4705						r#owns: r#owns_property.unwrap_or_default(),
4706						r#parent: r#parent_property.unwrap_or_default(),
4707						r#parents: r#parents_property.unwrap_or_default(),
4708						r#performer_in: r#performer_in_property.unwrap_or_default(),
4709						r#publishing_principles: r#publishing_principles_property
4710							.unwrap_or_default(),
4711						r#related_to: r#related_to_property.unwrap_or_default(),
4712						r#seeks: r#seeks_property.unwrap_or_default(),
4713						r#sibling: r#sibling_property.unwrap_or_default(),
4714						r#siblings: r#siblings_property.unwrap_or_default(),
4715						r#sponsor: r#sponsor_property.unwrap_or_default(),
4716						r#spouse: r#spouse_property.unwrap_or_default(),
4717						r#tax_id: r#tax_id_property.unwrap_or_default(),
4718						r#telephone: r#telephone_property.unwrap_or_default(),
4719						r#vat_id: r#vat_id_property.unwrap_or_default(),
4720						r#weight: r#weight_property.unwrap_or_default(),
4721						r#work_location: r#work_location_property.unwrap_or_default(),
4722						r#works_for: r#works_for_property.unwrap_or_default(),
4723						r#additional_type: r#additional_type_property.unwrap_or_default(),
4724						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
4725						r#description: r#description_property.unwrap_or_default(),
4726						r#disambiguating_description: r#disambiguating_description_property
4727							.unwrap_or_default(),
4728						r#identifier: r#identifier_property.unwrap_or_default(),
4729						r#image: r#image_property.unwrap_or_default(),
4730						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
4731						r#name: r#name_property.unwrap_or_default(),
4732						r#potential_action: r#potential_action_property.unwrap_or_default(),
4733						r#same_as: r#same_as_property.unwrap_or_default(),
4734						r#subject_of: r#subject_of_property.unwrap_or_default(),
4735						r#url: r#url_property.unwrap_or_default(),
4736					})
4737				}
4738			}
4739			const FIELDS: &[&str] = &[
4740				"additionalName",
4741				"address",
4742				"affiliation",
4743				"agentInteractionStatistic",
4744				"alumniOf",
4745				"award",
4746				"awards",
4747				"birthDate",
4748				"birthPlace",
4749				"brand",
4750				"callSign",
4751				"children",
4752				"colleague",
4753				"colleagues",
4754				"contactPoint",
4755				"contactPoints",
4756				"deathDate",
4757				"deathPlace",
4758				"duns",
4759				"email",
4760				"familyName",
4761				"faxNumber",
4762				"follows",
4763				"funder",
4764				"funding",
4765				"gender",
4766				"givenName",
4767				"globalLocationNumber",
4768				"hasCredential",
4769				"hasOccupation",
4770				"hasOfferCatalog",
4771				"hasPOS",
4772				"height",
4773				"homeLocation",
4774				"honorificPrefix",
4775				"honorificSuffix",
4776				"interactionStatistic",
4777				"isicV4",
4778				"jobTitle",
4779				"knows",
4780				"knowsAbout",
4781				"knowsLanguage",
4782				"makesOffer",
4783				"memberOf",
4784				"naics",
4785				"nationality",
4786				"netWorth",
4787				"owns",
4788				"parent",
4789				"parents",
4790				"performerIn",
4791				"publishingPrinciples",
4792				"relatedTo",
4793				"seeks",
4794				"sibling",
4795				"siblings",
4796				"sponsor",
4797				"spouse",
4798				"taxID",
4799				"telephone",
4800				"vatID",
4801				"weight",
4802				"workLocation",
4803				"worksFor",
4804				"additionalType",
4805				"alternateName",
4806				"description",
4807				"disambiguatingDescription",
4808				"identifier",
4809				"image",
4810				"mainEntityOfPage",
4811				"name",
4812				"potentialAction",
4813				"sameAs",
4814				"subjectOf",
4815				"url",
4816			];
4817			deserializer.deserialize_struct("Person", FIELDS, ClassVisitor)
4818		}
4819	}
4820}
schema_org_types/schemas/classes/person.rs

schema_org_types/schemas/classes/
person.rs
