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