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