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