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