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