1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Preschool {
6 pub r#opening_hours: Vec<OpeningHoursProperty>,
8 pub r#alumni: Vec<AlumniProperty>,
10 pub r#actionable_feedback_policy: Vec<ActionableFeedbackPolicyProperty>,
12 pub r#address: Vec<AddressProperty>,
14 pub r#agent_interaction_statistic: Vec<AgentInteractionStatisticProperty>,
16 pub r#aggregate_rating: Vec<AggregateRatingProperty>,
18 pub r#area_served: Vec<AreaServedProperty>,
20 pub r#award: Vec<AwardProperty>,
22 #[deprecated = "This schema is superseded by <https://schema.org/award>."]
24 pub r#awards: Vec<AwardsProperty>,
25 pub r#brand: Vec<BrandProperty>,
27 pub r#contact_point: Vec<ContactPointProperty>,
29 #[deprecated = "This schema is superseded by <https://schema.org/contactPoint>."]
31 pub r#contact_points: Vec<ContactPointsProperty>,
32 pub r#corrections_policy: Vec<CorrectionsPolicyProperty>,
34 pub r#department: Vec<DepartmentProperty>,
36 pub r#dissolution_date: Vec<DissolutionDateProperty>,
38 pub r#diversity_policy: Vec<DiversityPolicyProperty>,
40 pub r#diversity_staffing_report: Vec<DiversityStaffingReportProperty>,
42 pub r#duns: Vec<DunsProperty>,
44 pub r#email: Vec<EmailProperty>,
46 pub r#employee: Vec<EmployeeProperty>,
48 #[deprecated = "This schema is superseded by <https://schema.org/employee>."]
50 pub r#employees: Vec<EmployeesProperty>,
51 pub r#ethics_policy: Vec<EthicsPolicyProperty>,
53 pub r#event: Vec<EventProperty>,
55 #[deprecated = "This schema is superseded by <https://schema.org/event>."]
57 pub r#events: Vec<EventsProperty>,
58 pub r#fax_number: Vec<FaxNumberProperty>,
60 pub r#founder: Vec<FounderProperty>,
62 #[deprecated = "This schema is superseded by <https://schema.org/founder>."]
64 pub r#founders: Vec<FoundersProperty>,
65 pub r#founding_date: Vec<FoundingDateProperty>,
67 pub r#founding_location: Vec<FoundingLocationProperty>,
69 pub r#funder: Vec<FunderProperty>,
71 pub r#funding: Vec<FundingProperty>,
73 pub r#global_location_number: Vec<GlobalLocationNumberProperty>,
75 pub r#has_credential: Vec<HasCredentialProperty>,
77 pub r#has_merchant_return_policy: Vec<HasMerchantReturnPolicyProperty>,
79 pub r#has_offer_catalog: Vec<HasOfferCatalogProperty>,
81 pub r#has_pos: Vec<HasPosProperty>,
83 #[deprecated = "This schema is archived, see <https://schema.org/docs/attic.home.html>. This schema is superseded by <https://schema.org/hasMerchantReturnPolicy>."]
85 pub r#has_product_return_policy: Vec<HasProductReturnPolicyProperty>,
86 pub r#interaction_statistic: Vec<InteractionStatisticProperty>,
88 pub r#isic_v_4: Vec<IsicV4Property>,
90 pub r#iso_6523_code: Vec<Iso6523CodeProperty>,
92 pub r#keywords: Vec<KeywordsProperty>,
94 pub r#knows_about: Vec<KnowsAboutProperty>,
96 pub r#knows_language: Vec<KnowsLanguageProperty>,
98 pub r#legal_name: Vec<LegalNameProperty>,
100 pub r#lei_code: Vec<LeiCodeProperty>,
102 pub r#location: Vec<LocationProperty>,
104 pub r#logo: Vec<LogoProperty>,
106 pub r#makes_offer: Vec<MakesOfferProperty>,
108 pub r#member: Vec<MemberProperty>,
110 pub r#member_of: Vec<MemberOfProperty>,
112 #[deprecated = "This schema is superseded by <https://schema.org/member>."]
114 pub r#members: Vec<MembersProperty>,
115 pub r#naics: Vec<NaicsProperty>,
117 pub r#nonprofit_status: Vec<NonprofitStatusProperty>,
119 pub r#number_of_employees: Vec<NumberOfEmployeesProperty>,
121 pub r#ownership_funding_info: Vec<OwnershipFundingInfoProperty>,
123 pub r#owns: Vec<OwnsProperty>,
125 pub r#parent_organization: Vec<ParentOrganizationProperty>,
127 pub r#publishing_principles: Vec<PublishingPrinciplesProperty>,
129 pub r#review: Vec<ReviewProperty>,
131 #[deprecated = "This schema is superseded by <https://schema.org/review>."]
133 pub r#reviews: Vec<ReviewsProperty>,
134 pub r#seeks: Vec<SeeksProperty>,
136 #[deprecated = "This schema is superseded by <https://schema.org/areaServed>."]
138 pub r#service_area: Vec<ServiceAreaProperty>,
139 pub r#slogan: Vec<SloganProperty>,
141 pub r#sponsor: Vec<SponsorProperty>,
143 pub r#sub_organization: Vec<SubOrganizationProperty>,
145 pub r#tax_id: Vec<TaxIdProperty>,
147 pub r#telephone: Vec<TelephoneProperty>,
149 pub r#unnamed_sources_policy: Vec<UnnamedSourcesPolicyProperty>,
151 pub r#vat_id: Vec<VatIdProperty>,
153 pub r#additional_property: Vec<AdditionalPropertyProperty>,
155 pub r#amenity_feature: Vec<AmenityFeatureProperty>,
157 pub r#branch_code: Vec<BranchCodeProperty>,
159 #[deprecated = "This schema is superseded by <https://schema.org/containedInPlace>."]
161 pub r#contained_in: Vec<ContainedInProperty>,
162 pub r#contained_in_place: Vec<ContainedInPlaceProperty>,
164 pub r#contains_place: Vec<ContainsPlaceProperty>,
166 pub r#geo: Vec<GeoProperty>,
168 pub r#geo_contains: Vec<GeoContainsProperty>,
170 pub r#geo_covered_by: Vec<GeoCoveredByProperty>,
172 pub r#geo_covers: Vec<GeoCoversProperty>,
174 pub r#geo_crosses: Vec<GeoCrossesProperty>,
176 pub r#geo_disjoint: Vec<GeoDisjointProperty>,
178 pub r#geo_equals: Vec<GeoEqualsProperty>,
180 pub r#geo_intersects: Vec<GeoIntersectsProperty>,
182 pub r#geo_overlaps: Vec<GeoOverlapsProperty>,
184 pub r#geo_touches: Vec<GeoTouchesProperty>,
186 pub r#geo_within: Vec<GeoWithinProperty>,
188 pub r#has_drive_through_service: Vec<HasDriveThroughServiceProperty>,
190 pub r#has_map: Vec<HasMapProperty>,
192 pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
194 pub r#latitude: Vec<LatitudeProperty>,
196 pub r#longitude: Vec<LongitudeProperty>,
198 #[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
200 pub r#map: Vec<MapProperty>,
201 #[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
203 pub r#maps: Vec<MapsProperty>,
204 pub r#maximum_attendee_capacity: Vec<MaximumAttendeeCapacityProperty>,
206 pub r#opening_hours_specification: Vec<OpeningHoursSpecificationProperty>,
208 pub r#photo: Vec<PhotoProperty>,
210 #[deprecated = "This schema is superseded by <https://schema.org/photo>."]
212 pub r#photos: Vec<PhotosProperty>,
213 pub r#public_access: Vec<PublicAccessProperty>,
215 pub r#smoking_allowed: Vec<SmokingAllowedProperty>,
217 pub r#special_opening_hours_specification: Vec<SpecialOpeningHoursSpecificationProperty>,
219 pub r#tour_booking_page: Vec<TourBookingPageProperty>,
221 pub r#additional_type: Vec<AdditionalTypeProperty>,
223 pub r#alternate_name: Vec<AlternateNameProperty>,
225 pub r#description: Vec<DescriptionProperty>,
227 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
229 pub r#identifier: Vec<IdentifierProperty>,
231 pub r#image: Vec<ImageProperty>,
233 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
235 pub r#name: Vec<NameProperty>,
237 pub r#potential_action: Vec<PotentialActionProperty>,
239 pub r#same_as: Vec<SameAsProperty>,
241 pub r#subject_of: Vec<SubjectOfProperty>,
243 pub r#url: Vec<UrlProperty>,
245}
246pub trait PreschoolTrait {}
248impl PreschoolTrait for Preschool {}
249impl CivicStructureTrait for Preschool {
250 fn get_opening_hours(&self) -> &[OpeningHoursProperty] {
251 self.r#opening_hours.as_slice()
252 }
253 fn take_opening_hours(&mut self) -> Vec<OpeningHoursProperty> {
254 std::mem::take(&mut self.r#opening_hours)
255 }
256}
257impl EducationalOrganizationTrait for Preschool {
258 fn get_alumni(&self) -> &[AlumniProperty] {
259 self.r#alumni.as_slice()
260 }
261 fn take_alumni(&mut self) -> Vec<AlumniProperty> {
262 std::mem::take(&mut self.r#alumni)
263 }
264}
265impl OrganizationTrait for Preschool {
266 fn get_actionable_feedback_policy(&self) -> &[ActionableFeedbackPolicyProperty] {
267 self.r#actionable_feedback_policy.as_slice()
268 }
269 fn take_actionable_feedback_policy(&mut self) -> Vec<ActionableFeedbackPolicyProperty> {
270 std::mem::take(&mut self.r#actionable_feedback_policy)
271 }
272 fn get_address(&self) -> &[AddressProperty] {
273 self.r#address.as_slice()
274 }
275 fn take_address(&mut self) -> Vec<AddressProperty> {
276 std::mem::take(&mut self.r#address)
277 }
278 fn get_agent_interaction_statistic(&self) -> &[AgentInteractionStatisticProperty] {
279 self.r#agent_interaction_statistic.as_slice()
280 }
281 fn take_agent_interaction_statistic(&mut self) -> Vec<AgentInteractionStatisticProperty> {
282 std::mem::take(&mut self.r#agent_interaction_statistic)
283 }
284 fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
285 self.r#aggregate_rating.as_slice()
286 }
287 fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
288 std::mem::take(&mut self.r#aggregate_rating)
289 }
290 fn get_alumni(&self) -> &[AlumniProperty] {
291 self.r#alumni.as_slice()
292 }
293 fn take_alumni(&mut self) -> Vec<AlumniProperty> {
294 std::mem::take(&mut self.r#alumni)
295 }
296 fn get_area_served(&self) -> &[AreaServedProperty] {
297 self.r#area_served.as_slice()
298 }
299 fn take_area_served(&mut self) -> Vec<AreaServedProperty> {
300 std::mem::take(&mut self.r#area_served)
301 }
302 fn get_award(&self) -> &[AwardProperty] {
303 self.r#award.as_slice()
304 }
305 fn take_award(&mut self) -> Vec<AwardProperty> {
306 std::mem::take(&mut self.r#award)
307 }
308 fn get_awards(&self) -> &[AwardsProperty] {
309 self.r#awards.as_slice()
310 }
311 fn take_awards(&mut self) -> Vec<AwardsProperty> {
312 std::mem::take(&mut self.r#awards)
313 }
314 fn get_brand(&self) -> &[BrandProperty] {
315 self.r#brand.as_slice()
316 }
317 fn take_brand(&mut self) -> Vec<BrandProperty> {
318 std::mem::take(&mut self.r#brand)
319 }
320 fn get_contact_point(&self) -> &[ContactPointProperty] {
321 self.r#contact_point.as_slice()
322 }
323 fn take_contact_point(&mut self) -> Vec<ContactPointProperty> {
324 std::mem::take(&mut self.r#contact_point)
325 }
326 fn get_contact_points(&self) -> &[ContactPointsProperty] {
327 self.r#contact_points.as_slice()
328 }
329 fn take_contact_points(&mut self) -> Vec<ContactPointsProperty> {
330 std::mem::take(&mut self.r#contact_points)
331 }
332 fn get_corrections_policy(&self) -> &[CorrectionsPolicyProperty] {
333 self.r#corrections_policy.as_slice()
334 }
335 fn take_corrections_policy(&mut self) -> Vec<CorrectionsPolicyProperty> {
336 std::mem::take(&mut self.r#corrections_policy)
337 }
338 fn get_department(&self) -> &[DepartmentProperty] {
339 self.r#department.as_slice()
340 }
341 fn take_department(&mut self) -> Vec<DepartmentProperty> {
342 std::mem::take(&mut self.r#department)
343 }
344 fn get_dissolution_date(&self) -> &[DissolutionDateProperty] {
345 self.r#dissolution_date.as_slice()
346 }
347 fn take_dissolution_date(&mut self) -> Vec<DissolutionDateProperty> {
348 std::mem::take(&mut self.r#dissolution_date)
349 }
350 fn get_diversity_policy(&self) -> &[DiversityPolicyProperty] {
351 self.r#diversity_policy.as_slice()
352 }
353 fn take_diversity_policy(&mut self) -> Vec<DiversityPolicyProperty> {
354 std::mem::take(&mut self.r#diversity_policy)
355 }
356 fn get_diversity_staffing_report(&self) -> &[DiversityStaffingReportProperty] {
357 self.r#diversity_staffing_report.as_slice()
358 }
359 fn take_diversity_staffing_report(&mut self) -> Vec<DiversityStaffingReportProperty> {
360 std::mem::take(&mut self.r#diversity_staffing_report)
361 }
362 fn get_duns(&self) -> &[DunsProperty] {
363 self.r#duns.as_slice()
364 }
365 fn take_duns(&mut self) -> Vec<DunsProperty> {
366 std::mem::take(&mut self.r#duns)
367 }
368 fn get_email(&self) -> &[EmailProperty] {
369 self.r#email.as_slice()
370 }
371 fn take_email(&mut self) -> Vec<EmailProperty> {
372 std::mem::take(&mut self.r#email)
373 }
374 fn get_employee(&self) -> &[EmployeeProperty] {
375 self.r#employee.as_slice()
376 }
377 fn take_employee(&mut self) -> Vec<EmployeeProperty> {
378 std::mem::take(&mut self.r#employee)
379 }
380 fn get_employees(&self) -> &[EmployeesProperty] {
381 self.r#employees.as_slice()
382 }
383 fn take_employees(&mut self) -> Vec<EmployeesProperty> {
384 std::mem::take(&mut self.r#employees)
385 }
386 fn get_ethics_policy(&self) -> &[EthicsPolicyProperty] {
387 self.r#ethics_policy.as_slice()
388 }
389 fn take_ethics_policy(&mut self) -> Vec<EthicsPolicyProperty> {
390 std::mem::take(&mut self.r#ethics_policy)
391 }
392 fn get_event(&self) -> &[EventProperty] {
393 self.r#event.as_slice()
394 }
395 fn take_event(&mut self) -> Vec<EventProperty> {
396 std::mem::take(&mut self.r#event)
397 }
398 fn get_events(&self) -> &[EventsProperty] {
399 self.r#events.as_slice()
400 }
401 fn take_events(&mut self) -> Vec<EventsProperty> {
402 std::mem::take(&mut self.r#events)
403 }
404 fn get_fax_number(&self) -> &[FaxNumberProperty] {
405 self.r#fax_number.as_slice()
406 }
407 fn take_fax_number(&mut self) -> Vec<FaxNumberProperty> {
408 std::mem::take(&mut self.r#fax_number)
409 }
410 fn get_founder(&self) -> &[FounderProperty] {
411 self.r#founder.as_slice()
412 }
413 fn take_founder(&mut self) -> Vec<FounderProperty> {
414 std::mem::take(&mut self.r#founder)
415 }
416 fn get_founders(&self) -> &[FoundersProperty] {
417 self.r#founders.as_slice()
418 }
419 fn take_founders(&mut self) -> Vec<FoundersProperty> {
420 std::mem::take(&mut self.r#founders)
421 }
422 fn get_founding_date(&self) -> &[FoundingDateProperty] {
423 self.r#founding_date.as_slice()
424 }
425 fn take_founding_date(&mut self) -> Vec<FoundingDateProperty> {
426 std::mem::take(&mut self.r#founding_date)
427 }
428 fn get_founding_location(&self) -> &[FoundingLocationProperty] {
429 self.r#founding_location.as_slice()
430 }
431 fn take_founding_location(&mut self) -> Vec<FoundingLocationProperty> {
432 std::mem::take(&mut self.r#founding_location)
433 }
434 fn get_funder(&self) -> &[FunderProperty] {
435 self.r#funder.as_slice()
436 }
437 fn take_funder(&mut self) -> Vec<FunderProperty> {
438 std::mem::take(&mut self.r#funder)
439 }
440 fn get_funding(&self) -> &[FundingProperty] {
441 self.r#funding.as_slice()
442 }
443 fn take_funding(&mut self) -> Vec<FundingProperty> {
444 std::mem::take(&mut self.r#funding)
445 }
446 fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty] {
447 self.r#global_location_number.as_slice()
448 }
449 fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty> {
450 std::mem::take(&mut self.r#global_location_number)
451 }
452 fn get_has_credential(&self) -> &[HasCredentialProperty] {
453 self.r#has_credential.as_slice()
454 }
455 fn take_has_credential(&mut self) -> Vec<HasCredentialProperty> {
456 std::mem::take(&mut self.r#has_credential)
457 }
458 fn get_has_merchant_return_policy(&self) -> &[HasMerchantReturnPolicyProperty] {
459 self.r#has_merchant_return_policy.as_slice()
460 }
461 fn take_has_merchant_return_policy(&mut self) -> Vec<HasMerchantReturnPolicyProperty> {
462 std::mem::take(&mut self.r#has_merchant_return_policy)
463 }
464 fn get_has_offer_catalog(&self) -> &[HasOfferCatalogProperty] {
465 self.r#has_offer_catalog.as_slice()
466 }
467 fn take_has_offer_catalog(&mut self) -> Vec<HasOfferCatalogProperty> {
468 std::mem::take(&mut self.r#has_offer_catalog)
469 }
470 fn get_has_pos(&self) -> &[HasPosProperty] {
471 self.r#has_pos.as_slice()
472 }
473 fn take_has_pos(&mut self) -> Vec<HasPosProperty> {
474 std::mem::take(&mut self.r#has_pos)
475 }
476 fn get_has_product_return_policy(&self) -> &[HasProductReturnPolicyProperty] {
477 self.r#has_product_return_policy.as_slice()
478 }
479 fn take_has_product_return_policy(&mut self) -> Vec<HasProductReturnPolicyProperty> {
480 std::mem::take(&mut self.r#has_product_return_policy)
481 }
482 fn get_interaction_statistic(&self) -> &[InteractionStatisticProperty] {
483 self.r#interaction_statistic.as_slice()
484 }
485 fn take_interaction_statistic(&mut self) -> Vec<InteractionStatisticProperty> {
486 std::mem::take(&mut self.r#interaction_statistic)
487 }
488 fn get_isic_v_4(&self) -> &[IsicV4Property] {
489 self.r#isic_v_4.as_slice()
490 }
491 fn take_isic_v_4(&mut self) -> Vec<IsicV4Property> {
492 std::mem::take(&mut self.r#isic_v_4)
493 }
494 fn get_iso_6523_code(&self) -> &[Iso6523CodeProperty] {
495 self.r#iso_6523_code.as_slice()
496 }
497 fn take_iso_6523_code(&mut self) -> Vec<Iso6523CodeProperty> {
498 std::mem::take(&mut self.r#iso_6523_code)
499 }
500 fn get_keywords(&self) -> &[KeywordsProperty] {
501 self.r#keywords.as_slice()
502 }
503 fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
504 std::mem::take(&mut self.r#keywords)
505 }
506 fn get_knows_about(&self) -> &[KnowsAboutProperty] {
507 self.r#knows_about.as_slice()
508 }
509 fn take_knows_about(&mut self) -> Vec<KnowsAboutProperty> {
510 std::mem::take(&mut self.r#knows_about)
511 }
512 fn get_knows_language(&self) -> &[KnowsLanguageProperty] {
513 self.r#knows_language.as_slice()
514 }
515 fn take_knows_language(&mut self) -> Vec<KnowsLanguageProperty> {
516 std::mem::take(&mut self.r#knows_language)
517 }
518 fn get_legal_name(&self) -> &[LegalNameProperty] {
519 self.r#legal_name.as_slice()
520 }
521 fn take_legal_name(&mut self) -> Vec<LegalNameProperty> {
522 std::mem::take(&mut self.r#legal_name)
523 }
524 fn get_lei_code(&self) -> &[LeiCodeProperty] {
525 self.r#lei_code.as_slice()
526 }
527 fn take_lei_code(&mut self) -> Vec<LeiCodeProperty> {
528 std::mem::take(&mut self.r#lei_code)
529 }
530 fn get_location(&self) -> &[LocationProperty] {
531 self.r#location.as_slice()
532 }
533 fn take_location(&mut self) -> Vec<LocationProperty> {
534 std::mem::take(&mut self.r#location)
535 }
536 fn get_logo(&self) -> &[LogoProperty] {
537 self.r#logo.as_slice()
538 }
539 fn take_logo(&mut self) -> Vec<LogoProperty> {
540 std::mem::take(&mut self.r#logo)
541 }
542 fn get_makes_offer(&self) -> &[MakesOfferProperty] {
543 self.r#makes_offer.as_slice()
544 }
545 fn take_makes_offer(&mut self) -> Vec<MakesOfferProperty> {
546 std::mem::take(&mut self.r#makes_offer)
547 }
548 fn get_member(&self) -> &[MemberProperty] {
549 self.r#member.as_slice()
550 }
551 fn take_member(&mut self) -> Vec<MemberProperty> {
552 std::mem::take(&mut self.r#member)
553 }
554 fn get_member_of(&self) -> &[MemberOfProperty] {
555 self.r#member_of.as_slice()
556 }
557 fn take_member_of(&mut self) -> Vec<MemberOfProperty> {
558 std::mem::take(&mut self.r#member_of)
559 }
560 fn get_members(&self) -> &[MembersProperty] {
561 self.r#members.as_slice()
562 }
563 fn take_members(&mut self) -> Vec<MembersProperty> {
564 std::mem::take(&mut self.r#members)
565 }
566 fn get_naics(&self) -> &[NaicsProperty] {
567 self.r#naics.as_slice()
568 }
569 fn take_naics(&mut self) -> Vec<NaicsProperty> {
570 std::mem::take(&mut self.r#naics)
571 }
572 fn get_nonprofit_status(&self) -> &[NonprofitStatusProperty] {
573 self.r#nonprofit_status.as_slice()
574 }
575 fn take_nonprofit_status(&mut self) -> Vec<NonprofitStatusProperty> {
576 std::mem::take(&mut self.r#nonprofit_status)
577 }
578 fn get_number_of_employees(&self) -> &[NumberOfEmployeesProperty] {
579 self.r#number_of_employees.as_slice()
580 }
581 fn take_number_of_employees(&mut self) -> Vec<NumberOfEmployeesProperty> {
582 std::mem::take(&mut self.r#number_of_employees)
583 }
584 fn get_ownership_funding_info(&self) -> &[OwnershipFundingInfoProperty] {
585 self.r#ownership_funding_info.as_slice()
586 }
587 fn take_ownership_funding_info(&mut self) -> Vec<OwnershipFundingInfoProperty> {
588 std::mem::take(&mut self.r#ownership_funding_info)
589 }
590 fn get_owns(&self) -> &[OwnsProperty] {
591 self.r#owns.as_slice()
592 }
593 fn take_owns(&mut self) -> Vec<OwnsProperty> {
594 std::mem::take(&mut self.r#owns)
595 }
596 fn get_parent_organization(&self) -> &[ParentOrganizationProperty] {
597 self.r#parent_organization.as_slice()
598 }
599 fn take_parent_organization(&mut self) -> Vec<ParentOrganizationProperty> {
600 std::mem::take(&mut self.r#parent_organization)
601 }
602 fn get_publishing_principles(&self) -> &[PublishingPrinciplesProperty] {
603 self.r#publishing_principles.as_slice()
604 }
605 fn take_publishing_principles(&mut self) -> Vec<PublishingPrinciplesProperty> {
606 std::mem::take(&mut self.r#publishing_principles)
607 }
608 fn get_review(&self) -> &[ReviewProperty] {
609 self.r#review.as_slice()
610 }
611 fn take_review(&mut self) -> Vec<ReviewProperty> {
612 std::mem::take(&mut self.r#review)
613 }
614 fn get_reviews(&self) -> &[ReviewsProperty] {
615 self.r#reviews.as_slice()
616 }
617 fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
618 std::mem::take(&mut self.r#reviews)
619 }
620 fn get_seeks(&self) -> &[SeeksProperty] {
621 self.r#seeks.as_slice()
622 }
623 fn take_seeks(&mut self) -> Vec<SeeksProperty> {
624 std::mem::take(&mut self.r#seeks)
625 }
626 fn get_service_area(&self) -> &[ServiceAreaProperty] {
627 self.r#service_area.as_slice()
628 }
629 fn take_service_area(&mut self) -> Vec<ServiceAreaProperty> {
630 std::mem::take(&mut self.r#service_area)
631 }
632 fn get_slogan(&self) -> &[SloganProperty] {
633 self.r#slogan.as_slice()
634 }
635 fn take_slogan(&mut self) -> Vec<SloganProperty> {
636 std::mem::take(&mut self.r#slogan)
637 }
638 fn get_sponsor(&self) -> &[SponsorProperty] {
639 self.r#sponsor.as_slice()
640 }
641 fn take_sponsor(&mut self) -> Vec<SponsorProperty> {
642 std::mem::take(&mut self.r#sponsor)
643 }
644 fn get_sub_organization(&self) -> &[SubOrganizationProperty] {
645 self.r#sub_organization.as_slice()
646 }
647 fn take_sub_organization(&mut self) -> Vec<SubOrganizationProperty> {
648 std::mem::take(&mut self.r#sub_organization)
649 }
650 fn get_tax_id(&self) -> &[TaxIdProperty] {
651 self.r#tax_id.as_slice()
652 }
653 fn take_tax_id(&mut self) -> Vec<TaxIdProperty> {
654 std::mem::take(&mut self.r#tax_id)
655 }
656 fn get_telephone(&self) -> &[TelephoneProperty] {
657 self.r#telephone.as_slice()
658 }
659 fn take_telephone(&mut self) -> Vec<TelephoneProperty> {
660 std::mem::take(&mut self.r#telephone)
661 }
662 fn get_unnamed_sources_policy(&self) -> &[UnnamedSourcesPolicyProperty] {
663 self.r#unnamed_sources_policy.as_slice()
664 }
665 fn take_unnamed_sources_policy(&mut self) -> Vec<UnnamedSourcesPolicyProperty> {
666 std::mem::take(&mut self.r#unnamed_sources_policy)
667 }
668 fn get_vat_id(&self) -> &[VatIdProperty] {
669 self.r#vat_id.as_slice()
670 }
671 fn take_vat_id(&mut self) -> Vec<VatIdProperty> {
672 std::mem::take(&mut self.r#vat_id)
673 }
674}
675impl PlaceTrait for Preschool {
676 fn get_additional_property(&self) -> &[AdditionalPropertyProperty] {
677 self.r#additional_property.as_slice()
678 }
679 fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty> {
680 std::mem::take(&mut self.r#additional_property)
681 }
682 fn get_address(&self) -> &[AddressProperty] {
683 self.r#address.as_slice()
684 }
685 fn take_address(&mut self) -> Vec<AddressProperty> {
686 std::mem::take(&mut self.r#address)
687 }
688 fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
689 self.r#aggregate_rating.as_slice()
690 }
691 fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
692 std::mem::take(&mut self.r#aggregate_rating)
693 }
694 fn get_amenity_feature(&self) -> &[AmenityFeatureProperty] {
695 self.r#amenity_feature.as_slice()
696 }
697 fn take_amenity_feature(&mut self) -> Vec<AmenityFeatureProperty> {
698 std::mem::take(&mut self.r#amenity_feature)
699 }
700 fn get_branch_code(&self) -> &[BranchCodeProperty] {
701 self.r#branch_code.as_slice()
702 }
703 fn take_branch_code(&mut self) -> Vec<BranchCodeProperty> {
704 std::mem::take(&mut self.r#branch_code)
705 }
706 fn get_contained_in(&self) -> &[ContainedInProperty] {
707 self.r#contained_in.as_slice()
708 }
709 fn take_contained_in(&mut self) -> Vec<ContainedInProperty> {
710 std::mem::take(&mut self.r#contained_in)
711 }
712 fn get_contained_in_place(&self) -> &[ContainedInPlaceProperty] {
713 self.r#contained_in_place.as_slice()
714 }
715 fn take_contained_in_place(&mut self) -> Vec<ContainedInPlaceProperty> {
716 std::mem::take(&mut self.r#contained_in_place)
717 }
718 fn get_contains_place(&self) -> &[ContainsPlaceProperty] {
719 self.r#contains_place.as_slice()
720 }
721 fn take_contains_place(&mut self) -> Vec<ContainsPlaceProperty> {
722 std::mem::take(&mut self.r#contains_place)
723 }
724 fn get_event(&self) -> &[EventProperty] {
725 self.r#event.as_slice()
726 }
727 fn take_event(&mut self) -> Vec<EventProperty> {
728 std::mem::take(&mut self.r#event)
729 }
730 fn get_events(&self) -> &[EventsProperty] {
731 self.r#events.as_slice()
732 }
733 fn take_events(&mut self) -> Vec<EventsProperty> {
734 std::mem::take(&mut self.r#events)
735 }
736 fn get_fax_number(&self) -> &[FaxNumberProperty] {
737 self.r#fax_number.as_slice()
738 }
739 fn take_fax_number(&mut self) -> Vec<FaxNumberProperty> {
740 std::mem::take(&mut self.r#fax_number)
741 }
742 fn get_geo(&self) -> &[GeoProperty] {
743 self.r#geo.as_slice()
744 }
745 fn take_geo(&mut self) -> Vec<GeoProperty> {
746 std::mem::take(&mut self.r#geo)
747 }
748 fn get_geo_contains(&self) -> &[GeoContainsProperty] {
749 self.r#geo_contains.as_slice()
750 }
751 fn take_geo_contains(&mut self) -> Vec<GeoContainsProperty> {
752 std::mem::take(&mut self.r#geo_contains)
753 }
754 fn get_geo_covered_by(&self) -> &[GeoCoveredByProperty] {
755 self.r#geo_covered_by.as_slice()
756 }
757 fn take_geo_covered_by(&mut self) -> Vec<GeoCoveredByProperty> {
758 std::mem::take(&mut self.r#geo_covered_by)
759 }
760 fn get_geo_covers(&self) -> &[GeoCoversProperty] {
761 self.r#geo_covers.as_slice()
762 }
763 fn take_geo_covers(&mut self) -> Vec<GeoCoversProperty> {
764 std::mem::take(&mut self.r#geo_covers)
765 }
766 fn get_geo_crosses(&self) -> &[GeoCrossesProperty] {
767 self.r#geo_crosses.as_slice()
768 }
769 fn take_geo_crosses(&mut self) -> Vec<GeoCrossesProperty> {
770 std::mem::take(&mut self.r#geo_crosses)
771 }
772 fn get_geo_disjoint(&self) -> &[GeoDisjointProperty] {
773 self.r#geo_disjoint.as_slice()
774 }
775 fn take_geo_disjoint(&mut self) -> Vec<GeoDisjointProperty> {
776 std::mem::take(&mut self.r#geo_disjoint)
777 }
778 fn get_geo_equals(&self) -> &[GeoEqualsProperty] {
779 self.r#geo_equals.as_slice()
780 }
781 fn take_geo_equals(&mut self) -> Vec<GeoEqualsProperty> {
782 std::mem::take(&mut self.r#geo_equals)
783 }
784 fn get_geo_intersects(&self) -> &[GeoIntersectsProperty] {
785 self.r#geo_intersects.as_slice()
786 }
787 fn take_geo_intersects(&mut self) -> Vec<GeoIntersectsProperty> {
788 std::mem::take(&mut self.r#geo_intersects)
789 }
790 fn get_geo_overlaps(&self) -> &[GeoOverlapsProperty] {
791 self.r#geo_overlaps.as_slice()
792 }
793 fn take_geo_overlaps(&mut self) -> Vec<GeoOverlapsProperty> {
794 std::mem::take(&mut self.r#geo_overlaps)
795 }
796 fn get_geo_touches(&self) -> &[GeoTouchesProperty] {
797 self.r#geo_touches.as_slice()
798 }
799 fn take_geo_touches(&mut self) -> Vec<GeoTouchesProperty> {
800 std::mem::take(&mut self.r#geo_touches)
801 }
802 fn get_geo_within(&self) -> &[GeoWithinProperty] {
803 self.r#geo_within.as_slice()
804 }
805 fn take_geo_within(&mut self) -> Vec<GeoWithinProperty> {
806 std::mem::take(&mut self.r#geo_within)
807 }
808 fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty] {
809 self.r#global_location_number.as_slice()
810 }
811 fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty> {
812 std::mem::take(&mut self.r#global_location_number)
813 }
814 fn get_has_drive_through_service(&self) -> &[HasDriveThroughServiceProperty] {
815 self.r#has_drive_through_service.as_slice()
816 }
817 fn take_has_drive_through_service(&mut self) -> Vec<HasDriveThroughServiceProperty> {
818 std::mem::take(&mut self.r#has_drive_through_service)
819 }
820 fn get_has_map(&self) -> &[HasMapProperty] {
821 self.r#has_map.as_slice()
822 }
823 fn take_has_map(&mut self) -> Vec<HasMapProperty> {
824 std::mem::take(&mut self.r#has_map)
825 }
826 fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
827 self.r#is_accessible_for_free.as_slice()
828 }
829 fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
830 std::mem::take(&mut self.r#is_accessible_for_free)
831 }
832 fn get_isic_v_4(&self) -> &[IsicV4Property] {
833 self.r#isic_v_4.as_slice()
834 }
835 fn take_isic_v_4(&mut self) -> Vec<IsicV4Property> {
836 std::mem::take(&mut self.r#isic_v_4)
837 }
838 fn get_keywords(&self) -> &[KeywordsProperty] {
839 self.r#keywords.as_slice()
840 }
841 fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
842 std::mem::take(&mut self.r#keywords)
843 }
844 fn get_latitude(&self) -> &[LatitudeProperty] {
845 self.r#latitude.as_slice()
846 }
847 fn take_latitude(&mut self) -> Vec<LatitudeProperty> {
848 std::mem::take(&mut self.r#latitude)
849 }
850 fn get_logo(&self) -> &[LogoProperty] {
851 self.r#logo.as_slice()
852 }
853 fn take_logo(&mut self) -> Vec<LogoProperty> {
854 std::mem::take(&mut self.r#logo)
855 }
856 fn get_longitude(&self) -> &[LongitudeProperty] {
857 self.r#longitude.as_slice()
858 }
859 fn take_longitude(&mut self) -> Vec<LongitudeProperty> {
860 std::mem::take(&mut self.r#longitude)
861 }
862 fn get_map(&self) -> &[MapProperty] {
863 self.r#map.as_slice()
864 }
865 fn take_map(&mut self) -> Vec<MapProperty> {
866 std::mem::take(&mut self.r#map)
867 }
868 fn get_maps(&self) -> &[MapsProperty] {
869 self.r#maps.as_slice()
870 }
871 fn take_maps(&mut self) -> Vec<MapsProperty> {
872 std::mem::take(&mut self.r#maps)
873 }
874 fn get_maximum_attendee_capacity(&self) -> &[MaximumAttendeeCapacityProperty] {
875 self.r#maximum_attendee_capacity.as_slice()
876 }
877 fn take_maximum_attendee_capacity(&mut self) -> Vec<MaximumAttendeeCapacityProperty> {
878 std::mem::take(&mut self.r#maximum_attendee_capacity)
879 }
880 fn get_opening_hours_specification(&self) -> &[OpeningHoursSpecificationProperty] {
881 self.r#opening_hours_specification.as_slice()
882 }
883 fn take_opening_hours_specification(&mut self) -> Vec<OpeningHoursSpecificationProperty> {
884 std::mem::take(&mut self.r#opening_hours_specification)
885 }
886 fn get_photo(&self) -> &[PhotoProperty] {
887 self.r#photo.as_slice()
888 }
889 fn take_photo(&mut self) -> Vec<PhotoProperty> {
890 std::mem::take(&mut self.r#photo)
891 }
892 fn get_photos(&self) -> &[PhotosProperty] {
893 self.r#photos.as_slice()
894 }
895 fn take_photos(&mut self) -> Vec<PhotosProperty> {
896 std::mem::take(&mut self.r#photos)
897 }
898 fn get_public_access(&self) -> &[PublicAccessProperty] {
899 self.r#public_access.as_slice()
900 }
901 fn take_public_access(&mut self) -> Vec<PublicAccessProperty> {
902 std::mem::take(&mut self.r#public_access)
903 }
904 fn get_review(&self) -> &[ReviewProperty] {
905 self.r#review.as_slice()
906 }
907 fn take_review(&mut self) -> Vec<ReviewProperty> {
908 std::mem::take(&mut self.r#review)
909 }
910 fn get_reviews(&self) -> &[ReviewsProperty] {
911 self.r#reviews.as_slice()
912 }
913 fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
914 std::mem::take(&mut self.r#reviews)
915 }
916 fn get_slogan(&self) -> &[SloganProperty] {
917 self.r#slogan.as_slice()
918 }
919 fn take_slogan(&mut self) -> Vec<SloganProperty> {
920 std::mem::take(&mut self.r#slogan)
921 }
922 fn get_smoking_allowed(&self) -> &[SmokingAllowedProperty] {
923 self.r#smoking_allowed.as_slice()
924 }
925 fn take_smoking_allowed(&mut self) -> Vec<SmokingAllowedProperty> {
926 std::mem::take(&mut self.r#smoking_allowed)
927 }
928 fn get_special_opening_hours_specification(
929 &self,
930 ) -> &[SpecialOpeningHoursSpecificationProperty] {
931 self.r#special_opening_hours_specification.as_slice()
932 }
933 fn take_special_opening_hours_specification(
934 &mut self,
935 ) -> Vec<SpecialOpeningHoursSpecificationProperty> {
936 std::mem::take(&mut self.r#special_opening_hours_specification)
937 }
938 fn get_telephone(&self) -> &[TelephoneProperty] {
939 self.r#telephone.as_slice()
940 }
941 fn take_telephone(&mut self) -> Vec<TelephoneProperty> {
942 std::mem::take(&mut self.r#telephone)
943 }
944 fn get_tour_booking_page(&self) -> &[TourBookingPageProperty] {
945 self.r#tour_booking_page.as_slice()
946 }
947 fn take_tour_booking_page(&mut self) -> Vec<TourBookingPageProperty> {
948 std::mem::take(&mut self.r#tour_booking_page)
949 }
950}
951impl ThingTrait for Preschool {
952 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
953 self.r#additional_type.as_slice()
954 }
955 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
956 std::mem::take(&mut self.r#additional_type)
957 }
958 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
959 self.r#alternate_name.as_slice()
960 }
961 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
962 std::mem::take(&mut self.r#alternate_name)
963 }
964 fn get_description(&self) -> &[DescriptionProperty] {
965 self.r#description.as_slice()
966 }
967 fn take_description(&mut self) -> Vec<DescriptionProperty> {
968 std::mem::take(&mut self.r#description)
969 }
970 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
971 self.r#disambiguating_description.as_slice()
972 }
973 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
974 std::mem::take(&mut self.r#disambiguating_description)
975 }
976 fn get_identifier(&self) -> &[IdentifierProperty] {
977 self.r#identifier.as_slice()
978 }
979 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
980 std::mem::take(&mut self.r#identifier)
981 }
982 fn get_image(&self) -> &[ImageProperty] {
983 self.r#image.as_slice()
984 }
985 fn take_image(&mut self) -> Vec<ImageProperty> {
986 std::mem::take(&mut self.r#image)
987 }
988 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
989 self.r#main_entity_of_page.as_slice()
990 }
991 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
992 std::mem::take(&mut self.r#main_entity_of_page)
993 }
994 fn get_name(&self) -> &[NameProperty] {
995 self.r#name.as_slice()
996 }
997 fn take_name(&mut self) -> Vec<NameProperty> {
998 std::mem::take(&mut self.r#name)
999 }
1000 fn get_potential_action(&self) -> &[PotentialActionProperty] {
1001 self.r#potential_action.as_slice()
1002 }
1003 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
1004 std::mem::take(&mut self.r#potential_action)
1005 }
1006 fn get_same_as(&self) -> &[SameAsProperty] {
1007 self.r#same_as.as_slice()
1008 }
1009 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
1010 std::mem::take(&mut self.r#same_as)
1011 }
1012 fn get_subject_of(&self) -> &[SubjectOfProperty] {
1013 self.r#subject_of.as_slice()
1014 }
1015 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
1016 std::mem::take(&mut self.r#subject_of)
1017 }
1018 fn get_url(&self) -> &[UrlProperty] {
1019 self.r#url.as_slice()
1020 }
1021 fn take_url(&mut self) -> Vec<UrlProperty> {
1022 std::mem::take(&mut self.r#url)
1023 }
1024}
1025#[cfg(feature = "serde")]
1026mod serde {
1027 use std::{fmt, fmt::Formatter};
1028
1029 use ::serde::{
1030 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
1031 };
1032
1033 use super::*;
1034 impl Serialize for Preschool {
1035 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1036 where
1037 S: Serializer,
1038 {
1039 let len: usize = [
1040 !Vec::is_empty(&self.r#opening_hours) as usize,
1041 !Vec::is_empty(&self.r#alumni) as usize,
1042 !Vec::is_empty(&self.r#actionable_feedback_policy) as usize,
1043 !Vec::is_empty(&self.r#address) as usize,
1044 !Vec::is_empty(&self.r#agent_interaction_statistic) as usize,
1045 !Vec::is_empty(&self.r#aggregate_rating) as usize,
1046 !Vec::is_empty(&self.r#area_served) as usize,
1047 !Vec::is_empty(&self.r#award) as usize,
1048 !Vec::is_empty(&self.r#awards) as usize,
1049 !Vec::is_empty(&self.r#brand) as usize,
1050 !Vec::is_empty(&self.r#contact_point) as usize,
1051 !Vec::is_empty(&self.r#contact_points) as usize,
1052 !Vec::is_empty(&self.r#corrections_policy) as usize,
1053 !Vec::is_empty(&self.r#department) as usize,
1054 !Vec::is_empty(&self.r#dissolution_date) as usize,
1055 !Vec::is_empty(&self.r#diversity_policy) as usize,
1056 !Vec::is_empty(&self.r#diversity_staffing_report) as usize,
1057 !Vec::is_empty(&self.r#duns) as usize,
1058 !Vec::is_empty(&self.r#email) as usize,
1059 !Vec::is_empty(&self.r#employee) as usize,
1060 !Vec::is_empty(&self.r#employees) as usize,
1061 !Vec::is_empty(&self.r#ethics_policy) as usize,
1062 !Vec::is_empty(&self.r#event) as usize,
1063 !Vec::is_empty(&self.r#events) as usize,
1064 !Vec::is_empty(&self.r#fax_number) as usize,
1065 !Vec::is_empty(&self.r#founder) as usize,
1066 !Vec::is_empty(&self.r#founders) as usize,
1067 !Vec::is_empty(&self.r#founding_date) as usize,
1068 !Vec::is_empty(&self.r#founding_location) as usize,
1069 !Vec::is_empty(&self.r#funder) as usize,
1070 !Vec::is_empty(&self.r#funding) as usize,
1071 !Vec::is_empty(&self.r#global_location_number) as usize,
1072 !Vec::is_empty(&self.r#has_credential) as usize,
1073 !Vec::is_empty(&self.r#has_merchant_return_policy) as usize,
1074 !Vec::is_empty(&self.r#has_offer_catalog) as usize,
1075 !Vec::is_empty(&self.r#has_pos) as usize,
1076 !Vec::is_empty(&self.r#has_product_return_policy) as usize,
1077 !Vec::is_empty(&self.r#interaction_statistic) as usize,
1078 !Vec::is_empty(&self.r#isic_v_4) as usize,
1079 !Vec::is_empty(&self.r#iso_6523_code) as usize,
1080 !Vec::is_empty(&self.r#keywords) as usize,
1081 !Vec::is_empty(&self.r#knows_about) as usize,
1082 !Vec::is_empty(&self.r#knows_language) as usize,
1083 !Vec::is_empty(&self.r#legal_name) as usize,
1084 !Vec::is_empty(&self.r#lei_code) as usize,
1085 !Vec::is_empty(&self.r#location) as usize,
1086 !Vec::is_empty(&self.r#logo) as usize,
1087 !Vec::is_empty(&self.r#makes_offer) as usize,
1088 !Vec::is_empty(&self.r#member) as usize,
1089 !Vec::is_empty(&self.r#member_of) as usize,
1090 !Vec::is_empty(&self.r#members) as usize,
1091 !Vec::is_empty(&self.r#naics) as usize,
1092 !Vec::is_empty(&self.r#nonprofit_status) as usize,
1093 !Vec::is_empty(&self.r#number_of_employees) as usize,
1094 !Vec::is_empty(&self.r#ownership_funding_info) as usize,
1095 !Vec::is_empty(&self.r#owns) as usize,
1096 !Vec::is_empty(&self.r#parent_organization) as usize,
1097 !Vec::is_empty(&self.r#publishing_principles) as usize,
1098 !Vec::is_empty(&self.r#review) as usize,
1099 !Vec::is_empty(&self.r#reviews) as usize,
1100 !Vec::is_empty(&self.r#seeks) as usize,
1101 !Vec::is_empty(&self.r#service_area) as usize,
1102 !Vec::is_empty(&self.r#slogan) as usize,
1103 !Vec::is_empty(&self.r#sponsor) as usize,
1104 !Vec::is_empty(&self.r#sub_organization) as usize,
1105 !Vec::is_empty(&self.r#tax_id) as usize,
1106 !Vec::is_empty(&self.r#telephone) as usize,
1107 !Vec::is_empty(&self.r#unnamed_sources_policy) as usize,
1108 !Vec::is_empty(&self.r#vat_id) as usize,
1109 !Vec::is_empty(&self.r#additional_property) as usize,
1110 !Vec::is_empty(&self.r#amenity_feature) as usize,
1111 !Vec::is_empty(&self.r#branch_code) as usize,
1112 !Vec::is_empty(&self.r#contained_in) as usize,
1113 !Vec::is_empty(&self.r#contained_in_place) as usize,
1114 !Vec::is_empty(&self.r#contains_place) as usize,
1115 !Vec::is_empty(&self.r#geo) as usize,
1116 !Vec::is_empty(&self.r#geo_contains) as usize,
1117 !Vec::is_empty(&self.r#geo_covered_by) as usize,
1118 !Vec::is_empty(&self.r#geo_covers) as usize,
1119 !Vec::is_empty(&self.r#geo_crosses) as usize,
1120 !Vec::is_empty(&self.r#geo_disjoint) as usize,
1121 !Vec::is_empty(&self.r#geo_equals) as usize,
1122 !Vec::is_empty(&self.r#geo_intersects) as usize,
1123 !Vec::is_empty(&self.r#geo_overlaps) as usize,
1124 !Vec::is_empty(&self.r#geo_touches) as usize,
1125 !Vec::is_empty(&self.r#geo_within) as usize,
1126 !Vec::is_empty(&self.r#has_drive_through_service) as usize,
1127 !Vec::is_empty(&self.r#has_map) as usize,
1128 !Vec::is_empty(&self.r#is_accessible_for_free) as usize,
1129 !Vec::is_empty(&self.r#latitude) as usize,
1130 !Vec::is_empty(&self.r#longitude) as usize,
1131 !Vec::is_empty(&self.r#map) as usize,
1132 !Vec::is_empty(&self.r#maps) as usize,
1133 !Vec::is_empty(&self.r#maximum_attendee_capacity) as usize,
1134 !Vec::is_empty(&self.r#opening_hours_specification) as usize,
1135 !Vec::is_empty(&self.r#photo) as usize,
1136 !Vec::is_empty(&self.r#photos) as usize,
1137 !Vec::is_empty(&self.r#public_access) as usize,
1138 !Vec::is_empty(&self.r#smoking_allowed) as usize,
1139 !Vec::is_empty(&self.r#special_opening_hours_specification) as usize,
1140 !Vec::is_empty(&self.r#tour_booking_page) as usize,
1141 !Vec::is_empty(&self.r#additional_type) as usize,
1142 !Vec::is_empty(&self.r#alternate_name) as usize,
1143 !Vec::is_empty(&self.r#description) as usize,
1144 !Vec::is_empty(&self.r#disambiguating_description) as usize,
1145 !Vec::is_empty(&self.r#identifier) as usize,
1146 !Vec::is_empty(&self.r#image) as usize,
1147 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
1148 !Vec::is_empty(&self.r#name) as usize,
1149 !Vec::is_empty(&self.r#potential_action) as usize,
1150 !Vec::is_empty(&self.r#same_as) as usize,
1151 !Vec::is_empty(&self.r#subject_of) as usize,
1152 !Vec::is_empty(&self.r#url) as usize,
1153 ]
1154 .iter()
1155 .sum();
1156 let mut serialize_struct = Serializer::serialize_struct(serializer, "Preschool", len)?;
1157 if !Vec::is_empty(&self.r#opening_hours) {
1158 serialize_struct.serialize_field("openingHours", {
1159 struct SerializeWith<'a>(&'a Vec<OpeningHoursProperty>);
1160 impl<'a> Serialize for SerializeWith<'a> {
1161 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1162 where
1163 S: Serializer,
1164 {
1165 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1166 self.0, serializer,
1167 )
1168 }
1169 }
1170 &SerializeWith(&self.r#opening_hours)
1171 })?;
1172 } else {
1173 serialize_struct.skip_field("openingHours")?;
1174 }
1175 if !Vec::is_empty(&self.r#alumni) {
1176 serialize_struct.serialize_field("alumni", {
1177 struct SerializeWith<'a>(&'a Vec<AlumniProperty>);
1178 impl<'a> Serialize for SerializeWith<'a> {
1179 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1180 where
1181 S: Serializer,
1182 {
1183 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1184 self.0, serializer,
1185 )
1186 }
1187 }
1188 &SerializeWith(&self.r#alumni)
1189 })?;
1190 } else {
1191 serialize_struct.skip_field("alumni")?;
1192 }
1193 if !Vec::is_empty(&self.r#actionable_feedback_policy) {
1194 serialize_struct.serialize_field("actionableFeedbackPolicy", {
1195 struct SerializeWith<'a>(&'a Vec<ActionableFeedbackPolicyProperty>);
1196 impl<'a> Serialize for SerializeWith<'a> {
1197 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1198 where
1199 S: Serializer,
1200 {
1201 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1202 self.0, serializer,
1203 )
1204 }
1205 }
1206 &SerializeWith(&self.r#actionable_feedback_policy)
1207 })?;
1208 } else {
1209 serialize_struct.skip_field("actionableFeedbackPolicy")?;
1210 }
1211 if !Vec::is_empty(&self.r#address) {
1212 serialize_struct.serialize_field("address", {
1213 struct SerializeWith<'a>(&'a Vec<AddressProperty>);
1214 impl<'a> Serialize for SerializeWith<'a> {
1215 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1216 where
1217 S: Serializer,
1218 {
1219 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1220 self.0, serializer,
1221 )
1222 }
1223 }
1224 &SerializeWith(&self.r#address)
1225 })?;
1226 } else {
1227 serialize_struct.skip_field("address")?;
1228 }
1229 if !Vec::is_empty(&self.r#agent_interaction_statistic) {
1230 serialize_struct.serialize_field("agentInteractionStatistic", {
1231 struct SerializeWith<'a>(&'a Vec<AgentInteractionStatisticProperty>);
1232 impl<'a> Serialize for SerializeWith<'a> {
1233 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1234 where
1235 S: Serializer,
1236 {
1237 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1238 self.0, serializer,
1239 )
1240 }
1241 }
1242 &SerializeWith(&self.r#agent_interaction_statistic)
1243 })?;
1244 } else {
1245 serialize_struct.skip_field("agentInteractionStatistic")?;
1246 }
1247 if !Vec::is_empty(&self.r#aggregate_rating) {
1248 serialize_struct.serialize_field("aggregateRating", {
1249 struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
1250 impl<'a> Serialize for SerializeWith<'a> {
1251 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1252 where
1253 S: Serializer,
1254 {
1255 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1256 self.0, serializer,
1257 )
1258 }
1259 }
1260 &SerializeWith(&self.r#aggregate_rating)
1261 })?;
1262 } else {
1263 serialize_struct.skip_field("aggregateRating")?;
1264 }
1265 if !Vec::is_empty(&self.r#area_served) {
1266 serialize_struct.serialize_field("areaServed", {
1267 struct SerializeWith<'a>(&'a Vec<AreaServedProperty>);
1268 impl<'a> Serialize for SerializeWith<'a> {
1269 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1270 where
1271 S: Serializer,
1272 {
1273 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1274 self.0, serializer,
1275 )
1276 }
1277 }
1278 &SerializeWith(&self.r#area_served)
1279 })?;
1280 } else {
1281 serialize_struct.skip_field("areaServed")?;
1282 }
1283 if !Vec::is_empty(&self.r#award) {
1284 serialize_struct.serialize_field("award", {
1285 struct SerializeWith<'a>(&'a Vec<AwardProperty>);
1286 impl<'a> Serialize for SerializeWith<'a> {
1287 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1288 where
1289 S: Serializer,
1290 {
1291 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1292 self.0, serializer,
1293 )
1294 }
1295 }
1296 &SerializeWith(&self.r#award)
1297 })?;
1298 } else {
1299 serialize_struct.skip_field("award")?;
1300 }
1301 if !Vec::is_empty(&self.r#awards) {
1302 serialize_struct.serialize_field("awards", {
1303 struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
1304 impl<'a> Serialize for SerializeWith<'a> {
1305 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1306 where
1307 S: Serializer,
1308 {
1309 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1310 self.0, serializer,
1311 )
1312 }
1313 }
1314 &SerializeWith(&self.r#awards)
1315 })?;
1316 } else {
1317 serialize_struct.skip_field("awards")?;
1318 }
1319 if !Vec::is_empty(&self.r#brand) {
1320 serialize_struct.serialize_field("brand", {
1321 struct SerializeWith<'a>(&'a Vec<BrandProperty>);
1322 impl<'a> Serialize for SerializeWith<'a> {
1323 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1324 where
1325 S: Serializer,
1326 {
1327 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1328 self.0, serializer,
1329 )
1330 }
1331 }
1332 &SerializeWith(&self.r#brand)
1333 })?;
1334 } else {
1335 serialize_struct.skip_field("brand")?;
1336 }
1337 if !Vec::is_empty(&self.r#contact_point) {
1338 serialize_struct.serialize_field("contactPoint", {
1339 struct SerializeWith<'a>(&'a Vec<ContactPointProperty>);
1340 impl<'a> Serialize for SerializeWith<'a> {
1341 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1342 where
1343 S: Serializer,
1344 {
1345 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1346 self.0, serializer,
1347 )
1348 }
1349 }
1350 &SerializeWith(&self.r#contact_point)
1351 })?;
1352 } else {
1353 serialize_struct.skip_field("contactPoint")?;
1354 }
1355 if !Vec::is_empty(&self.r#contact_points) {
1356 serialize_struct.serialize_field("contactPoints", {
1357 struct SerializeWith<'a>(&'a Vec<ContactPointsProperty>);
1358 impl<'a> Serialize for SerializeWith<'a> {
1359 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1360 where
1361 S: Serializer,
1362 {
1363 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1364 self.0, serializer,
1365 )
1366 }
1367 }
1368 &SerializeWith(&self.r#contact_points)
1369 })?;
1370 } else {
1371 serialize_struct.skip_field("contactPoints")?;
1372 }
1373 if !Vec::is_empty(&self.r#corrections_policy) {
1374 serialize_struct.serialize_field("correctionsPolicy", {
1375 struct SerializeWith<'a>(&'a Vec<CorrectionsPolicyProperty>);
1376 impl<'a> Serialize for SerializeWith<'a> {
1377 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1378 where
1379 S: Serializer,
1380 {
1381 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1382 self.0, serializer,
1383 )
1384 }
1385 }
1386 &SerializeWith(&self.r#corrections_policy)
1387 })?;
1388 } else {
1389 serialize_struct.skip_field("correctionsPolicy")?;
1390 }
1391 if !Vec::is_empty(&self.r#department) {
1392 serialize_struct.serialize_field("department", {
1393 struct SerializeWith<'a>(&'a Vec<DepartmentProperty>);
1394 impl<'a> Serialize for SerializeWith<'a> {
1395 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1396 where
1397 S: Serializer,
1398 {
1399 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1400 self.0, serializer,
1401 )
1402 }
1403 }
1404 &SerializeWith(&self.r#department)
1405 })?;
1406 } else {
1407 serialize_struct.skip_field("department")?;
1408 }
1409 if !Vec::is_empty(&self.r#dissolution_date) {
1410 serialize_struct.serialize_field("dissolutionDate", {
1411 struct SerializeWith<'a>(&'a Vec<DissolutionDateProperty>);
1412 impl<'a> Serialize for SerializeWith<'a> {
1413 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1414 where
1415 S: Serializer,
1416 {
1417 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1418 self.0, serializer,
1419 )
1420 }
1421 }
1422 &SerializeWith(&self.r#dissolution_date)
1423 })?;
1424 } else {
1425 serialize_struct.skip_field("dissolutionDate")?;
1426 }
1427 if !Vec::is_empty(&self.r#diversity_policy) {
1428 serialize_struct.serialize_field("diversityPolicy", {
1429 struct SerializeWith<'a>(&'a Vec<DiversityPolicyProperty>);
1430 impl<'a> Serialize for SerializeWith<'a> {
1431 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1432 where
1433 S: Serializer,
1434 {
1435 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1436 self.0, serializer,
1437 )
1438 }
1439 }
1440 &SerializeWith(&self.r#diversity_policy)
1441 })?;
1442 } else {
1443 serialize_struct.skip_field("diversityPolicy")?;
1444 }
1445 if !Vec::is_empty(&self.r#diversity_staffing_report) {
1446 serialize_struct.serialize_field("diversityStaffingReport", {
1447 struct SerializeWith<'a>(&'a Vec<DiversityStaffingReportProperty>);
1448 impl<'a> Serialize for SerializeWith<'a> {
1449 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1450 where
1451 S: Serializer,
1452 {
1453 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1454 self.0, serializer,
1455 )
1456 }
1457 }
1458 &SerializeWith(&self.r#diversity_staffing_report)
1459 })?;
1460 } else {
1461 serialize_struct.skip_field("diversityStaffingReport")?;
1462 }
1463 if !Vec::is_empty(&self.r#duns) {
1464 serialize_struct.serialize_field("duns", {
1465 struct SerializeWith<'a>(&'a Vec<DunsProperty>);
1466 impl<'a> Serialize for SerializeWith<'a> {
1467 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1468 where
1469 S: Serializer,
1470 {
1471 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1472 self.0, serializer,
1473 )
1474 }
1475 }
1476 &SerializeWith(&self.r#duns)
1477 })?;
1478 } else {
1479 serialize_struct.skip_field("duns")?;
1480 }
1481 if !Vec::is_empty(&self.r#email) {
1482 serialize_struct.serialize_field("email", {
1483 struct SerializeWith<'a>(&'a Vec<EmailProperty>);
1484 impl<'a> Serialize for SerializeWith<'a> {
1485 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1486 where
1487 S: Serializer,
1488 {
1489 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1490 self.0, serializer,
1491 )
1492 }
1493 }
1494 &SerializeWith(&self.r#email)
1495 })?;
1496 } else {
1497 serialize_struct.skip_field("email")?;
1498 }
1499 if !Vec::is_empty(&self.r#employee) {
1500 serialize_struct.serialize_field("employee", {
1501 struct SerializeWith<'a>(&'a Vec<EmployeeProperty>);
1502 impl<'a> Serialize for SerializeWith<'a> {
1503 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1504 where
1505 S: Serializer,
1506 {
1507 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1508 self.0, serializer,
1509 )
1510 }
1511 }
1512 &SerializeWith(&self.r#employee)
1513 })?;
1514 } else {
1515 serialize_struct.skip_field("employee")?;
1516 }
1517 if !Vec::is_empty(&self.r#employees) {
1518 serialize_struct.serialize_field("employees", {
1519 struct SerializeWith<'a>(&'a Vec<EmployeesProperty>);
1520 impl<'a> Serialize for SerializeWith<'a> {
1521 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1522 where
1523 S: Serializer,
1524 {
1525 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1526 self.0, serializer,
1527 )
1528 }
1529 }
1530 &SerializeWith(&self.r#employees)
1531 })?;
1532 } else {
1533 serialize_struct.skip_field("employees")?;
1534 }
1535 if !Vec::is_empty(&self.r#ethics_policy) {
1536 serialize_struct.serialize_field("ethicsPolicy", {
1537 struct SerializeWith<'a>(&'a Vec<EthicsPolicyProperty>);
1538 impl<'a> Serialize for SerializeWith<'a> {
1539 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1540 where
1541 S: Serializer,
1542 {
1543 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1544 self.0, serializer,
1545 )
1546 }
1547 }
1548 &SerializeWith(&self.r#ethics_policy)
1549 })?;
1550 } else {
1551 serialize_struct.skip_field("ethicsPolicy")?;
1552 }
1553 if !Vec::is_empty(&self.r#event) {
1554 serialize_struct.serialize_field("event", {
1555 struct SerializeWith<'a>(&'a Vec<EventProperty>);
1556 impl<'a> Serialize for SerializeWith<'a> {
1557 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1558 where
1559 S: Serializer,
1560 {
1561 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1562 self.0, serializer,
1563 )
1564 }
1565 }
1566 &SerializeWith(&self.r#event)
1567 })?;
1568 } else {
1569 serialize_struct.skip_field("event")?;
1570 }
1571 if !Vec::is_empty(&self.r#events) {
1572 serialize_struct.serialize_field("events", {
1573 struct SerializeWith<'a>(&'a Vec<EventsProperty>);
1574 impl<'a> Serialize for SerializeWith<'a> {
1575 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1576 where
1577 S: Serializer,
1578 {
1579 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1580 self.0, serializer,
1581 )
1582 }
1583 }
1584 &SerializeWith(&self.r#events)
1585 })?;
1586 } else {
1587 serialize_struct.skip_field("events")?;
1588 }
1589 if !Vec::is_empty(&self.r#fax_number) {
1590 serialize_struct.serialize_field("faxNumber", {
1591 struct SerializeWith<'a>(&'a Vec<FaxNumberProperty>);
1592 impl<'a> Serialize for SerializeWith<'a> {
1593 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1594 where
1595 S: Serializer,
1596 {
1597 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1598 self.0, serializer,
1599 )
1600 }
1601 }
1602 &SerializeWith(&self.r#fax_number)
1603 })?;
1604 } else {
1605 serialize_struct.skip_field("faxNumber")?;
1606 }
1607 if !Vec::is_empty(&self.r#founder) {
1608 serialize_struct.serialize_field("founder", {
1609 struct SerializeWith<'a>(&'a Vec<FounderProperty>);
1610 impl<'a> Serialize for SerializeWith<'a> {
1611 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1612 where
1613 S: Serializer,
1614 {
1615 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1616 self.0, serializer,
1617 )
1618 }
1619 }
1620 &SerializeWith(&self.r#founder)
1621 })?;
1622 } else {
1623 serialize_struct.skip_field("founder")?;
1624 }
1625 if !Vec::is_empty(&self.r#founders) {
1626 serialize_struct.serialize_field("founders", {
1627 struct SerializeWith<'a>(&'a Vec<FoundersProperty>);
1628 impl<'a> Serialize for SerializeWith<'a> {
1629 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1630 where
1631 S: Serializer,
1632 {
1633 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1634 self.0, serializer,
1635 )
1636 }
1637 }
1638 &SerializeWith(&self.r#founders)
1639 })?;
1640 } else {
1641 serialize_struct.skip_field("founders")?;
1642 }
1643 if !Vec::is_empty(&self.r#founding_date) {
1644 serialize_struct.serialize_field("foundingDate", {
1645 struct SerializeWith<'a>(&'a Vec<FoundingDateProperty>);
1646 impl<'a> Serialize for SerializeWith<'a> {
1647 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1648 where
1649 S: Serializer,
1650 {
1651 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1652 self.0, serializer,
1653 )
1654 }
1655 }
1656 &SerializeWith(&self.r#founding_date)
1657 })?;
1658 } else {
1659 serialize_struct.skip_field("foundingDate")?;
1660 }
1661 if !Vec::is_empty(&self.r#founding_location) {
1662 serialize_struct.serialize_field("foundingLocation", {
1663 struct SerializeWith<'a>(&'a Vec<FoundingLocationProperty>);
1664 impl<'a> Serialize for SerializeWith<'a> {
1665 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1666 where
1667 S: Serializer,
1668 {
1669 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1670 self.0, serializer,
1671 )
1672 }
1673 }
1674 &SerializeWith(&self.r#founding_location)
1675 })?;
1676 } else {
1677 serialize_struct.skip_field("foundingLocation")?;
1678 }
1679 if !Vec::is_empty(&self.r#funder) {
1680 serialize_struct.serialize_field("funder", {
1681 struct SerializeWith<'a>(&'a Vec<FunderProperty>);
1682 impl<'a> Serialize for SerializeWith<'a> {
1683 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1684 where
1685 S: Serializer,
1686 {
1687 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1688 self.0, serializer,
1689 )
1690 }
1691 }
1692 &SerializeWith(&self.r#funder)
1693 })?;
1694 } else {
1695 serialize_struct.skip_field("funder")?;
1696 }
1697 if !Vec::is_empty(&self.r#funding) {
1698 serialize_struct.serialize_field("funding", {
1699 struct SerializeWith<'a>(&'a Vec<FundingProperty>);
1700 impl<'a> Serialize for SerializeWith<'a> {
1701 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1702 where
1703 S: Serializer,
1704 {
1705 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1706 self.0, serializer,
1707 )
1708 }
1709 }
1710 &SerializeWith(&self.r#funding)
1711 })?;
1712 } else {
1713 serialize_struct.skip_field("funding")?;
1714 }
1715 if !Vec::is_empty(&self.r#global_location_number) {
1716 serialize_struct.serialize_field("globalLocationNumber", {
1717 struct SerializeWith<'a>(&'a Vec<GlobalLocationNumberProperty>);
1718 impl<'a> Serialize for SerializeWith<'a> {
1719 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1720 where
1721 S: Serializer,
1722 {
1723 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1724 self.0, serializer,
1725 )
1726 }
1727 }
1728 &SerializeWith(&self.r#global_location_number)
1729 })?;
1730 } else {
1731 serialize_struct.skip_field("globalLocationNumber")?;
1732 }
1733 if !Vec::is_empty(&self.r#has_credential) {
1734 serialize_struct.serialize_field("hasCredential", {
1735 struct SerializeWith<'a>(&'a Vec<HasCredentialProperty>);
1736 impl<'a> Serialize for SerializeWith<'a> {
1737 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1738 where
1739 S: Serializer,
1740 {
1741 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1742 self.0, serializer,
1743 )
1744 }
1745 }
1746 &SerializeWith(&self.r#has_credential)
1747 })?;
1748 } else {
1749 serialize_struct.skip_field("hasCredential")?;
1750 }
1751 if !Vec::is_empty(&self.r#has_merchant_return_policy) {
1752 serialize_struct.serialize_field("hasMerchantReturnPolicy", {
1753 struct SerializeWith<'a>(&'a Vec<HasMerchantReturnPolicyProperty>);
1754 impl<'a> Serialize for SerializeWith<'a> {
1755 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1756 where
1757 S: Serializer,
1758 {
1759 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1760 self.0, serializer,
1761 )
1762 }
1763 }
1764 &SerializeWith(&self.r#has_merchant_return_policy)
1765 })?;
1766 } else {
1767 serialize_struct.skip_field("hasMerchantReturnPolicy")?;
1768 }
1769 if !Vec::is_empty(&self.r#has_offer_catalog) {
1770 serialize_struct.serialize_field("hasOfferCatalog", {
1771 struct SerializeWith<'a>(&'a Vec<HasOfferCatalogProperty>);
1772 impl<'a> Serialize for SerializeWith<'a> {
1773 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1774 where
1775 S: Serializer,
1776 {
1777 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1778 self.0, serializer,
1779 )
1780 }
1781 }
1782 &SerializeWith(&self.r#has_offer_catalog)
1783 })?;
1784 } else {
1785 serialize_struct.skip_field("hasOfferCatalog")?;
1786 }
1787 if !Vec::is_empty(&self.r#has_pos) {
1788 serialize_struct.serialize_field("hasPOS", {
1789 struct SerializeWith<'a>(&'a Vec<HasPosProperty>);
1790 impl<'a> Serialize for SerializeWith<'a> {
1791 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1792 where
1793 S: Serializer,
1794 {
1795 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1796 self.0, serializer,
1797 )
1798 }
1799 }
1800 &SerializeWith(&self.r#has_pos)
1801 })?;
1802 } else {
1803 serialize_struct.skip_field("hasPOS")?;
1804 }
1805 if !Vec::is_empty(&self.r#has_product_return_policy) {
1806 serialize_struct.serialize_field("hasProductReturnPolicy", {
1807 struct SerializeWith<'a>(&'a Vec<HasProductReturnPolicyProperty>);
1808 impl<'a> Serialize for SerializeWith<'a> {
1809 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1810 where
1811 S: Serializer,
1812 {
1813 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1814 self.0, serializer,
1815 )
1816 }
1817 }
1818 &SerializeWith(&self.r#has_product_return_policy)
1819 })?;
1820 } else {
1821 serialize_struct.skip_field("hasProductReturnPolicy")?;
1822 }
1823 if !Vec::is_empty(&self.r#interaction_statistic) {
1824 serialize_struct.serialize_field("interactionStatistic", {
1825 struct SerializeWith<'a>(&'a Vec<InteractionStatisticProperty>);
1826 impl<'a> Serialize for SerializeWith<'a> {
1827 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1828 where
1829 S: Serializer,
1830 {
1831 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1832 self.0, serializer,
1833 )
1834 }
1835 }
1836 &SerializeWith(&self.r#interaction_statistic)
1837 })?;
1838 } else {
1839 serialize_struct.skip_field("interactionStatistic")?;
1840 }
1841 if !Vec::is_empty(&self.r#isic_v_4) {
1842 serialize_struct.serialize_field("isicV4", {
1843 struct SerializeWith<'a>(&'a Vec<IsicV4Property>);
1844 impl<'a> Serialize for SerializeWith<'a> {
1845 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1846 where
1847 S: Serializer,
1848 {
1849 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1850 self.0, serializer,
1851 )
1852 }
1853 }
1854 &SerializeWith(&self.r#isic_v_4)
1855 })?;
1856 } else {
1857 serialize_struct.skip_field("isicV4")?;
1858 }
1859 if !Vec::is_empty(&self.r#iso_6523_code) {
1860 serialize_struct.serialize_field("iso6523Code", {
1861 struct SerializeWith<'a>(&'a Vec<Iso6523CodeProperty>);
1862 impl<'a> Serialize for SerializeWith<'a> {
1863 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1864 where
1865 S: Serializer,
1866 {
1867 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1868 self.0, serializer,
1869 )
1870 }
1871 }
1872 &SerializeWith(&self.r#iso_6523_code)
1873 })?;
1874 } else {
1875 serialize_struct.skip_field("iso6523Code")?;
1876 }
1877 if !Vec::is_empty(&self.r#keywords) {
1878 serialize_struct.serialize_field("keywords", {
1879 struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
1880 impl<'a> Serialize for SerializeWith<'a> {
1881 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1882 where
1883 S: Serializer,
1884 {
1885 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1886 self.0, serializer,
1887 )
1888 }
1889 }
1890 &SerializeWith(&self.r#keywords)
1891 })?;
1892 } else {
1893 serialize_struct.skip_field("keywords")?;
1894 }
1895 if !Vec::is_empty(&self.r#knows_about) {
1896 serialize_struct.serialize_field("knowsAbout", {
1897 struct SerializeWith<'a>(&'a Vec<KnowsAboutProperty>);
1898 impl<'a> Serialize for SerializeWith<'a> {
1899 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1900 where
1901 S: Serializer,
1902 {
1903 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1904 self.0, serializer,
1905 )
1906 }
1907 }
1908 &SerializeWith(&self.r#knows_about)
1909 })?;
1910 } else {
1911 serialize_struct.skip_field("knowsAbout")?;
1912 }
1913 if !Vec::is_empty(&self.r#knows_language) {
1914 serialize_struct.serialize_field("knowsLanguage", {
1915 struct SerializeWith<'a>(&'a Vec<KnowsLanguageProperty>);
1916 impl<'a> Serialize for SerializeWith<'a> {
1917 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1918 where
1919 S: Serializer,
1920 {
1921 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1922 self.0, serializer,
1923 )
1924 }
1925 }
1926 &SerializeWith(&self.r#knows_language)
1927 })?;
1928 } else {
1929 serialize_struct.skip_field("knowsLanguage")?;
1930 }
1931 if !Vec::is_empty(&self.r#legal_name) {
1932 serialize_struct.serialize_field("legalName", {
1933 struct SerializeWith<'a>(&'a Vec<LegalNameProperty>);
1934 impl<'a> Serialize for SerializeWith<'a> {
1935 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1936 where
1937 S: Serializer,
1938 {
1939 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1940 self.0, serializer,
1941 )
1942 }
1943 }
1944 &SerializeWith(&self.r#legal_name)
1945 })?;
1946 } else {
1947 serialize_struct.skip_field("legalName")?;
1948 }
1949 if !Vec::is_empty(&self.r#lei_code) {
1950 serialize_struct.serialize_field("leiCode", {
1951 struct SerializeWith<'a>(&'a Vec<LeiCodeProperty>);
1952 impl<'a> Serialize for SerializeWith<'a> {
1953 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1954 where
1955 S: Serializer,
1956 {
1957 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1958 self.0, serializer,
1959 )
1960 }
1961 }
1962 &SerializeWith(&self.r#lei_code)
1963 })?;
1964 } else {
1965 serialize_struct.skip_field("leiCode")?;
1966 }
1967 if !Vec::is_empty(&self.r#location) {
1968 serialize_struct.serialize_field("location", {
1969 struct SerializeWith<'a>(&'a Vec<LocationProperty>);
1970 impl<'a> Serialize for SerializeWith<'a> {
1971 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1972 where
1973 S: Serializer,
1974 {
1975 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1976 self.0, serializer,
1977 )
1978 }
1979 }
1980 &SerializeWith(&self.r#location)
1981 })?;
1982 } else {
1983 serialize_struct.skip_field("location")?;
1984 }
1985 if !Vec::is_empty(&self.r#logo) {
1986 serialize_struct.serialize_field("logo", {
1987 struct SerializeWith<'a>(&'a Vec<LogoProperty>);
1988 impl<'a> Serialize for SerializeWith<'a> {
1989 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1990 where
1991 S: Serializer,
1992 {
1993 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1994 self.0, serializer,
1995 )
1996 }
1997 }
1998 &SerializeWith(&self.r#logo)
1999 })?;
2000 } else {
2001 serialize_struct.skip_field("logo")?;
2002 }
2003 if !Vec::is_empty(&self.r#makes_offer) {
2004 serialize_struct.serialize_field("makesOffer", {
2005 struct SerializeWith<'a>(&'a Vec<MakesOfferProperty>);
2006 impl<'a> Serialize for SerializeWith<'a> {
2007 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2008 where
2009 S: Serializer,
2010 {
2011 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2012 self.0, serializer,
2013 )
2014 }
2015 }
2016 &SerializeWith(&self.r#makes_offer)
2017 })?;
2018 } else {
2019 serialize_struct.skip_field("makesOffer")?;
2020 }
2021 if !Vec::is_empty(&self.r#member) {
2022 serialize_struct.serialize_field("member", {
2023 struct SerializeWith<'a>(&'a Vec<MemberProperty>);
2024 impl<'a> Serialize for SerializeWith<'a> {
2025 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2026 where
2027 S: Serializer,
2028 {
2029 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2030 self.0, serializer,
2031 )
2032 }
2033 }
2034 &SerializeWith(&self.r#member)
2035 })?;
2036 } else {
2037 serialize_struct.skip_field("member")?;
2038 }
2039 if !Vec::is_empty(&self.r#member_of) {
2040 serialize_struct.serialize_field("memberOf", {
2041 struct SerializeWith<'a>(&'a Vec<MemberOfProperty>);
2042 impl<'a> Serialize for SerializeWith<'a> {
2043 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2044 where
2045 S: Serializer,
2046 {
2047 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2048 self.0, serializer,
2049 )
2050 }
2051 }
2052 &SerializeWith(&self.r#member_of)
2053 })?;
2054 } else {
2055 serialize_struct.skip_field("memberOf")?;
2056 }
2057 if !Vec::is_empty(&self.r#members) {
2058 serialize_struct.serialize_field("members", {
2059 struct SerializeWith<'a>(&'a Vec<MembersProperty>);
2060 impl<'a> Serialize for SerializeWith<'a> {
2061 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2062 where
2063 S: Serializer,
2064 {
2065 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2066 self.0, serializer,
2067 )
2068 }
2069 }
2070 &SerializeWith(&self.r#members)
2071 })?;
2072 } else {
2073 serialize_struct.skip_field("members")?;
2074 }
2075 if !Vec::is_empty(&self.r#naics) {
2076 serialize_struct.serialize_field("naics", {
2077 struct SerializeWith<'a>(&'a Vec<NaicsProperty>);
2078 impl<'a> Serialize for SerializeWith<'a> {
2079 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2080 where
2081 S: Serializer,
2082 {
2083 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2084 self.0, serializer,
2085 )
2086 }
2087 }
2088 &SerializeWith(&self.r#naics)
2089 })?;
2090 } else {
2091 serialize_struct.skip_field("naics")?;
2092 }
2093 if !Vec::is_empty(&self.r#nonprofit_status) {
2094 serialize_struct.serialize_field("nonprofitStatus", {
2095 struct SerializeWith<'a>(&'a Vec<NonprofitStatusProperty>);
2096 impl<'a> Serialize for SerializeWith<'a> {
2097 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2098 where
2099 S: Serializer,
2100 {
2101 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2102 self.0, serializer,
2103 )
2104 }
2105 }
2106 &SerializeWith(&self.r#nonprofit_status)
2107 })?;
2108 } else {
2109 serialize_struct.skip_field("nonprofitStatus")?;
2110 }
2111 if !Vec::is_empty(&self.r#number_of_employees) {
2112 serialize_struct.serialize_field("numberOfEmployees", {
2113 struct SerializeWith<'a>(&'a Vec<NumberOfEmployeesProperty>);
2114 impl<'a> Serialize for SerializeWith<'a> {
2115 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2116 where
2117 S: Serializer,
2118 {
2119 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2120 self.0, serializer,
2121 )
2122 }
2123 }
2124 &SerializeWith(&self.r#number_of_employees)
2125 })?;
2126 } else {
2127 serialize_struct.skip_field("numberOfEmployees")?;
2128 }
2129 if !Vec::is_empty(&self.r#ownership_funding_info) {
2130 serialize_struct.serialize_field("ownershipFundingInfo", {
2131 struct SerializeWith<'a>(&'a Vec<OwnershipFundingInfoProperty>);
2132 impl<'a> Serialize for SerializeWith<'a> {
2133 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2134 where
2135 S: Serializer,
2136 {
2137 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2138 self.0, serializer,
2139 )
2140 }
2141 }
2142 &SerializeWith(&self.r#ownership_funding_info)
2143 })?;
2144 } else {
2145 serialize_struct.skip_field("ownershipFundingInfo")?;
2146 }
2147 if !Vec::is_empty(&self.r#owns) {
2148 serialize_struct.serialize_field("owns", {
2149 struct SerializeWith<'a>(&'a Vec<OwnsProperty>);
2150 impl<'a> Serialize for SerializeWith<'a> {
2151 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2152 where
2153 S: Serializer,
2154 {
2155 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2156 self.0, serializer,
2157 )
2158 }
2159 }
2160 &SerializeWith(&self.r#owns)
2161 })?;
2162 } else {
2163 serialize_struct.skip_field("owns")?;
2164 }
2165 if !Vec::is_empty(&self.r#parent_organization) {
2166 serialize_struct.serialize_field("parentOrganization", {
2167 struct SerializeWith<'a>(&'a Vec<ParentOrganizationProperty>);
2168 impl<'a> Serialize for SerializeWith<'a> {
2169 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2170 where
2171 S: Serializer,
2172 {
2173 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2174 self.0, serializer,
2175 )
2176 }
2177 }
2178 &SerializeWith(&self.r#parent_organization)
2179 })?;
2180 } else {
2181 serialize_struct.skip_field("parentOrganization")?;
2182 }
2183 if !Vec::is_empty(&self.r#publishing_principles) {
2184 serialize_struct.serialize_field("publishingPrinciples", {
2185 struct SerializeWith<'a>(&'a Vec<PublishingPrinciplesProperty>);
2186 impl<'a> Serialize for SerializeWith<'a> {
2187 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2188 where
2189 S: Serializer,
2190 {
2191 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2192 self.0, serializer,
2193 )
2194 }
2195 }
2196 &SerializeWith(&self.r#publishing_principles)
2197 })?;
2198 } else {
2199 serialize_struct.skip_field("publishingPrinciples")?;
2200 }
2201 if !Vec::is_empty(&self.r#review) {
2202 serialize_struct.serialize_field("review", {
2203 struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
2204 impl<'a> Serialize for SerializeWith<'a> {
2205 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2206 where
2207 S: Serializer,
2208 {
2209 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2210 self.0, serializer,
2211 )
2212 }
2213 }
2214 &SerializeWith(&self.r#review)
2215 })?;
2216 } else {
2217 serialize_struct.skip_field("review")?;
2218 }
2219 if !Vec::is_empty(&self.r#reviews) {
2220 serialize_struct.serialize_field("reviews", {
2221 struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
2222 impl<'a> Serialize for SerializeWith<'a> {
2223 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2224 where
2225 S: Serializer,
2226 {
2227 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2228 self.0, serializer,
2229 )
2230 }
2231 }
2232 &SerializeWith(&self.r#reviews)
2233 })?;
2234 } else {
2235 serialize_struct.skip_field("reviews")?;
2236 }
2237 if !Vec::is_empty(&self.r#seeks) {
2238 serialize_struct.serialize_field("seeks", {
2239 struct SerializeWith<'a>(&'a Vec<SeeksProperty>);
2240 impl<'a> Serialize for SerializeWith<'a> {
2241 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2242 where
2243 S: Serializer,
2244 {
2245 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2246 self.0, serializer,
2247 )
2248 }
2249 }
2250 &SerializeWith(&self.r#seeks)
2251 })?;
2252 } else {
2253 serialize_struct.skip_field("seeks")?;
2254 }
2255 if !Vec::is_empty(&self.r#service_area) {
2256 serialize_struct.serialize_field("serviceArea", {
2257 struct SerializeWith<'a>(&'a Vec<ServiceAreaProperty>);
2258 impl<'a> Serialize for SerializeWith<'a> {
2259 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2260 where
2261 S: Serializer,
2262 {
2263 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2264 self.0, serializer,
2265 )
2266 }
2267 }
2268 &SerializeWith(&self.r#service_area)
2269 })?;
2270 } else {
2271 serialize_struct.skip_field("serviceArea")?;
2272 }
2273 if !Vec::is_empty(&self.r#slogan) {
2274 serialize_struct.serialize_field("slogan", {
2275 struct SerializeWith<'a>(&'a Vec<SloganProperty>);
2276 impl<'a> Serialize for SerializeWith<'a> {
2277 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2278 where
2279 S: Serializer,
2280 {
2281 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2282 self.0, serializer,
2283 )
2284 }
2285 }
2286 &SerializeWith(&self.r#slogan)
2287 })?;
2288 } else {
2289 serialize_struct.skip_field("slogan")?;
2290 }
2291 if !Vec::is_empty(&self.r#sponsor) {
2292 serialize_struct.serialize_field("sponsor", {
2293 struct SerializeWith<'a>(&'a Vec<SponsorProperty>);
2294 impl<'a> Serialize for SerializeWith<'a> {
2295 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2296 where
2297 S: Serializer,
2298 {
2299 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2300 self.0, serializer,
2301 )
2302 }
2303 }
2304 &SerializeWith(&self.r#sponsor)
2305 })?;
2306 } else {
2307 serialize_struct.skip_field("sponsor")?;
2308 }
2309 if !Vec::is_empty(&self.r#sub_organization) {
2310 serialize_struct.serialize_field("subOrganization", {
2311 struct SerializeWith<'a>(&'a Vec<SubOrganizationProperty>);
2312 impl<'a> Serialize for SerializeWith<'a> {
2313 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2314 where
2315 S: Serializer,
2316 {
2317 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2318 self.0, serializer,
2319 )
2320 }
2321 }
2322 &SerializeWith(&self.r#sub_organization)
2323 })?;
2324 } else {
2325 serialize_struct.skip_field("subOrganization")?;
2326 }
2327 if !Vec::is_empty(&self.r#tax_id) {
2328 serialize_struct.serialize_field("taxID", {
2329 struct SerializeWith<'a>(&'a Vec<TaxIdProperty>);
2330 impl<'a> Serialize for SerializeWith<'a> {
2331 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2332 where
2333 S: Serializer,
2334 {
2335 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2336 self.0, serializer,
2337 )
2338 }
2339 }
2340 &SerializeWith(&self.r#tax_id)
2341 })?;
2342 } else {
2343 serialize_struct.skip_field("taxID")?;
2344 }
2345 if !Vec::is_empty(&self.r#telephone) {
2346 serialize_struct.serialize_field("telephone", {
2347 struct SerializeWith<'a>(&'a Vec<TelephoneProperty>);
2348 impl<'a> Serialize for SerializeWith<'a> {
2349 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2350 where
2351 S: Serializer,
2352 {
2353 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2354 self.0, serializer,
2355 )
2356 }
2357 }
2358 &SerializeWith(&self.r#telephone)
2359 })?;
2360 } else {
2361 serialize_struct.skip_field("telephone")?;
2362 }
2363 if !Vec::is_empty(&self.r#unnamed_sources_policy) {
2364 serialize_struct.serialize_field("unnamedSourcesPolicy", {
2365 struct SerializeWith<'a>(&'a Vec<UnnamedSourcesPolicyProperty>);
2366 impl<'a> Serialize for SerializeWith<'a> {
2367 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2368 where
2369 S: Serializer,
2370 {
2371 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2372 self.0, serializer,
2373 )
2374 }
2375 }
2376 &SerializeWith(&self.r#unnamed_sources_policy)
2377 })?;
2378 } else {
2379 serialize_struct.skip_field("unnamedSourcesPolicy")?;
2380 }
2381 if !Vec::is_empty(&self.r#vat_id) {
2382 serialize_struct.serialize_field("vatID", {
2383 struct SerializeWith<'a>(&'a Vec<VatIdProperty>);
2384 impl<'a> Serialize for SerializeWith<'a> {
2385 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2386 where
2387 S: Serializer,
2388 {
2389 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2390 self.0, serializer,
2391 )
2392 }
2393 }
2394 &SerializeWith(&self.r#vat_id)
2395 })?;
2396 } else {
2397 serialize_struct.skip_field("vatID")?;
2398 }
2399 if !Vec::is_empty(&self.r#additional_property) {
2400 serialize_struct.serialize_field("additionalProperty", {
2401 struct SerializeWith<'a>(&'a Vec<AdditionalPropertyProperty>);
2402 impl<'a> Serialize for SerializeWith<'a> {
2403 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2404 where
2405 S: Serializer,
2406 {
2407 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2408 self.0, serializer,
2409 )
2410 }
2411 }
2412 &SerializeWith(&self.r#additional_property)
2413 })?;
2414 } else {
2415 serialize_struct.skip_field("additionalProperty")?;
2416 }
2417 if !Vec::is_empty(&self.r#amenity_feature) {
2418 serialize_struct.serialize_field("amenityFeature", {
2419 struct SerializeWith<'a>(&'a Vec<AmenityFeatureProperty>);
2420 impl<'a> Serialize for SerializeWith<'a> {
2421 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2422 where
2423 S: Serializer,
2424 {
2425 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2426 self.0, serializer,
2427 )
2428 }
2429 }
2430 &SerializeWith(&self.r#amenity_feature)
2431 })?;
2432 } else {
2433 serialize_struct.skip_field("amenityFeature")?;
2434 }
2435 if !Vec::is_empty(&self.r#branch_code) {
2436 serialize_struct.serialize_field("branchCode", {
2437 struct SerializeWith<'a>(&'a Vec<BranchCodeProperty>);
2438 impl<'a> Serialize for SerializeWith<'a> {
2439 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2440 where
2441 S: Serializer,
2442 {
2443 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2444 self.0, serializer,
2445 )
2446 }
2447 }
2448 &SerializeWith(&self.r#branch_code)
2449 })?;
2450 } else {
2451 serialize_struct.skip_field("branchCode")?;
2452 }
2453 if !Vec::is_empty(&self.r#contained_in) {
2454 serialize_struct.serialize_field("containedIn", {
2455 struct SerializeWith<'a>(&'a Vec<ContainedInProperty>);
2456 impl<'a> Serialize for SerializeWith<'a> {
2457 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2458 where
2459 S: Serializer,
2460 {
2461 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2462 self.0, serializer,
2463 )
2464 }
2465 }
2466 &SerializeWith(&self.r#contained_in)
2467 })?;
2468 } else {
2469 serialize_struct.skip_field("containedIn")?;
2470 }
2471 if !Vec::is_empty(&self.r#contained_in_place) {
2472 serialize_struct.serialize_field("containedInPlace", {
2473 struct SerializeWith<'a>(&'a Vec<ContainedInPlaceProperty>);
2474 impl<'a> Serialize for SerializeWith<'a> {
2475 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2476 where
2477 S: Serializer,
2478 {
2479 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2480 self.0, serializer,
2481 )
2482 }
2483 }
2484 &SerializeWith(&self.r#contained_in_place)
2485 })?;
2486 } else {
2487 serialize_struct.skip_field("containedInPlace")?;
2488 }
2489 if !Vec::is_empty(&self.r#contains_place) {
2490 serialize_struct.serialize_field("containsPlace", {
2491 struct SerializeWith<'a>(&'a Vec<ContainsPlaceProperty>);
2492 impl<'a> Serialize for SerializeWith<'a> {
2493 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2494 where
2495 S: Serializer,
2496 {
2497 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2498 self.0, serializer,
2499 )
2500 }
2501 }
2502 &SerializeWith(&self.r#contains_place)
2503 })?;
2504 } else {
2505 serialize_struct.skip_field("containsPlace")?;
2506 }
2507 if !Vec::is_empty(&self.r#geo) {
2508 serialize_struct.serialize_field("geo", {
2509 struct SerializeWith<'a>(&'a Vec<GeoProperty>);
2510 impl<'a> Serialize for SerializeWith<'a> {
2511 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2512 where
2513 S: Serializer,
2514 {
2515 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2516 self.0, serializer,
2517 )
2518 }
2519 }
2520 &SerializeWith(&self.r#geo)
2521 })?;
2522 } else {
2523 serialize_struct.skip_field("geo")?;
2524 }
2525 if !Vec::is_empty(&self.r#geo_contains) {
2526 serialize_struct.serialize_field("geoContains", {
2527 struct SerializeWith<'a>(&'a Vec<GeoContainsProperty>);
2528 impl<'a> Serialize for SerializeWith<'a> {
2529 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2530 where
2531 S: Serializer,
2532 {
2533 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2534 self.0, serializer,
2535 )
2536 }
2537 }
2538 &SerializeWith(&self.r#geo_contains)
2539 })?;
2540 } else {
2541 serialize_struct.skip_field("geoContains")?;
2542 }
2543 if !Vec::is_empty(&self.r#geo_covered_by) {
2544 serialize_struct.serialize_field("geoCoveredBy", {
2545 struct SerializeWith<'a>(&'a Vec<GeoCoveredByProperty>);
2546 impl<'a> Serialize for SerializeWith<'a> {
2547 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2548 where
2549 S: Serializer,
2550 {
2551 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2552 self.0, serializer,
2553 )
2554 }
2555 }
2556 &SerializeWith(&self.r#geo_covered_by)
2557 })?;
2558 } else {
2559 serialize_struct.skip_field("geoCoveredBy")?;
2560 }
2561 if !Vec::is_empty(&self.r#geo_covers) {
2562 serialize_struct.serialize_field("geoCovers", {
2563 struct SerializeWith<'a>(&'a Vec<GeoCoversProperty>);
2564 impl<'a> Serialize for SerializeWith<'a> {
2565 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2566 where
2567 S: Serializer,
2568 {
2569 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2570 self.0, serializer,
2571 )
2572 }
2573 }
2574 &SerializeWith(&self.r#geo_covers)
2575 })?;
2576 } else {
2577 serialize_struct.skip_field("geoCovers")?;
2578 }
2579 if !Vec::is_empty(&self.r#geo_crosses) {
2580 serialize_struct.serialize_field("geoCrosses", {
2581 struct SerializeWith<'a>(&'a Vec<GeoCrossesProperty>);
2582 impl<'a> Serialize for SerializeWith<'a> {
2583 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2584 where
2585 S: Serializer,
2586 {
2587 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2588 self.0, serializer,
2589 )
2590 }
2591 }
2592 &SerializeWith(&self.r#geo_crosses)
2593 })?;
2594 } else {
2595 serialize_struct.skip_field("geoCrosses")?;
2596 }
2597 if !Vec::is_empty(&self.r#geo_disjoint) {
2598 serialize_struct.serialize_field("geoDisjoint", {
2599 struct SerializeWith<'a>(&'a Vec<GeoDisjointProperty>);
2600 impl<'a> Serialize for SerializeWith<'a> {
2601 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2602 where
2603 S: Serializer,
2604 {
2605 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2606 self.0, serializer,
2607 )
2608 }
2609 }
2610 &SerializeWith(&self.r#geo_disjoint)
2611 })?;
2612 } else {
2613 serialize_struct.skip_field("geoDisjoint")?;
2614 }
2615 if !Vec::is_empty(&self.r#geo_equals) {
2616 serialize_struct.serialize_field("geoEquals", {
2617 struct SerializeWith<'a>(&'a Vec<GeoEqualsProperty>);
2618 impl<'a> Serialize for SerializeWith<'a> {
2619 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2620 where
2621 S: Serializer,
2622 {
2623 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2624 self.0, serializer,
2625 )
2626 }
2627 }
2628 &SerializeWith(&self.r#geo_equals)
2629 })?;
2630 } else {
2631 serialize_struct.skip_field("geoEquals")?;
2632 }
2633 if !Vec::is_empty(&self.r#geo_intersects) {
2634 serialize_struct.serialize_field("geoIntersects", {
2635 struct SerializeWith<'a>(&'a Vec<GeoIntersectsProperty>);
2636 impl<'a> Serialize for SerializeWith<'a> {
2637 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2638 where
2639 S: Serializer,
2640 {
2641 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2642 self.0, serializer,
2643 )
2644 }
2645 }
2646 &SerializeWith(&self.r#geo_intersects)
2647 })?;
2648 } else {
2649 serialize_struct.skip_field("geoIntersects")?;
2650 }
2651 if !Vec::is_empty(&self.r#geo_overlaps) {
2652 serialize_struct.serialize_field("geoOverlaps", {
2653 struct SerializeWith<'a>(&'a Vec<GeoOverlapsProperty>);
2654 impl<'a> Serialize for SerializeWith<'a> {
2655 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2656 where
2657 S: Serializer,
2658 {
2659 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2660 self.0, serializer,
2661 )
2662 }
2663 }
2664 &SerializeWith(&self.r#geo_overlaps)
2665 })?;
2666 } else {
2667 serialize_struct.skip_field("geoOverlaps")?;
2668 }
2669 if !Vec::is_empty(&self.r#geo_touches) {
2670 serialize_struct.serialize_field("geoTouches", {
2671 struct SerializeWith<'a>(&'a Vec<GeoTouchesProperty>);
2672 impl<'a> Serialize for SerializeWith<'a> {
2673 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2674 where
2675 S: Serializer,
2676 {
2677 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2678 self.0, serializer,
2679 )
2680 }
2681 }
2682 &SerializeWith(&self.r#geo_touches)
2683 })?;
2684 } else {
2685 serialize_struct.skip_field("geoTouches")?;
2686 }
2687 if !Vec::is_empty(&self.r#geo_within) {
2688 serialize_struct.serialize_field("geoWithin", {
2689 struct SerializeWith<'a>(&'a Vec<GeoWithinProperty>);
2690 impl<'a> Serialize for SerializeWith<'a> {
2691 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2692 where
2693 S: Serializer,
2694 {
2695 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2696 self.0, serializer,
2697 )
2698 }
2699 }
2700 &SerializeWith(&self.r#geo_within)
2701 })?;
2702 } else {
2703 serialize_struct.skip_field("geoWithin")?;
2704 }
2705 if !Vec::is_empty(&self.r#has_drive_through_service) {
2706 serialize_struct.serialize_field("hasDriveThroughService", {
2707 struct SerializeWith<'a>(&'a Vec<HasDriveThroughServiceProperty>);
2708 impl<'a> Serialize for SerializeWith<'a> {
2709 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2710 where
2711 S: Serializer,
2712 {
2713 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2714 self.0, serializer,
2715 )
2716 }
2717 }
2718 &SerializeWith(&self.r#has_drive_through_service)
2719 })?;
2720 } else {
2721 serialize_struct.skip_field("hasDriveThroughService")?;
2722 }
2723 if !Vec::is_empty(&self.r#has_map) {
2724 serialize_struct.serialize_field("hasMap", {
2725 struct SerializeWith<'a>(&'a Vec<HasMapProperty>);
2726 impl<'a> Serialize for SerializeWith<'a> {
2727 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2728 where
2729 S: Serializer,
2730 {
2731 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2732 self.0, serializer,
2733 )
2734 }
2735 }
2736 &SerializeWith(&self.r#has_map)
2737 })?;
2738 } else {
2739 serialize_struct.skip_field("hasMap")?;
2740 }
2741 if !Vec::is_empty(&self.r#is_accessible_for_free) {
2742 serialize_struct.serialize_field("isAccessibleForFree", {
2743 struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
2744 impl<'a> Serialize for SerializeWith<'a> {
2745 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2746 where
2747 S: Serializer,
2748 {
2749 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2750 self.0, serializer,
2751 )
2752 }
2753 }
2754 &SerializeWith(&self.r#is_accessible_for_free)
2755 })?;
2756 } else {
2757 serialize_struct.skip_field("isAccessibleForFree")?;
2758 }
2759 if !Vec::is_empty(&self.r#latitude) {
2760 serialize_struct.serialize_field("latitude", {
2761 struct SerializeWith<'a>(&'a Vec<LatitudeProperty>);
2762 impl<'a> Serialize for SerializeWith<'a> {
2763 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2764 where
2765 S: Serializer,
2766 {
2767 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2768 self.0, serializer,
2769 )
2770 }
2771 }
2772 &SerializeWith(&self.r#latitude)
2773 })?;
2774 } else {
2775 serialize_struct.skip_field("latitude")?;
2776 }
2777 if !Vec::is_empty(&self.r#longitude) {
2778 serialize_struct.serialize_field("longitude", {
2779 struct SerializeWith<'a>(&'a Vec<LongitudeProperty>);
2780 impl<'a> Serialize for SerializeWith<'a> {
2781 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2782 where
2783 S: Serializer,
2784 {
2785 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2786 self.0, serializer,
2787 )
2788 }
2789 }
2790 &SerializeWith(&self.r#longitude)
2791 })?;
2792 } else {
2793 serialize_struct.skip_field("longitude")?;
2794 }
2795 if !Vec::is_empty(&self.r#map) {
2796 serialize_struct.serialize_field("map", {
2797 struct SerializeWith<'a>(&'a Vec<MapProperty>);
2798 impl<'a> Serialize for SerializeWith<'a> {
2799 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2800 where
2801 S: Serializer,
2802 {
2803 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2804 self.0, serializer,
2805 )
2806 }
2807 }
2808 &SerializeWith(&self.r#map)
2809 })?;
2810 } else {
2811 serialize_struct.skip_field("map")?;
2812 }
2813 if !Vec::is_empty(&self.r#maps) {
2814 serialize_struct.serialize_field("maps", {
2815 struct SerializeWith<'a>(&'a Vec<MapsProperty>);
2816 impl<'a> Serialize for SerializeWith<'a> {
2817 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2818 where
2819 S: Serializer,
2820 {
2821 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2822 self.0, serializer,
2823 )
2824 }
2825 }
2826 &SerializeWith(&self.r#maps)
2827 })?;
2828 } else {
2829 serialize_struct.skip_field("maps")?;
2830 }
2831 if !Vec::is_empty(&self.r#maximum_attendee_capacity) {
2832 serialize_struct.serialize_field("maximumAttendeeCapacity", {
2833 struct SerializeWith<'a>(&'a Vec<MaximumAttendeeCapacityProperty>);
2834 impl<'a> Serialize for SerializeWith<'a> {
2835 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2836 where
2837 S: Serializer,
2838 {
2839 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2840 self.0, serializer,
2841 )
2842 }
2843 }
2844 &SerializeWith(&self.r#maximum_attendee_capacity)
2845 })?;
2846 } else {
2847 serialize_struct.skip_field("maximumAttendeeCapacity")?;
2848 }
2849 if !Vec::is_empty(&self.r#opening_hours_specification) {
2850 serialize_struct.serialize_field("openingHoursSpecification", {
2851 struct SerializeWith<'a>(&'a Vec<OpeningHoursSpecificationProperty>);
2852 impl<'a> Serialize for SerializeWith<'a> {
2853 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2854 where
2855 S: Serializer,
2856 {
2857 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2858 self.0, serializer,
2859 )
2860 }
2861 }
2862 &SerializeWith(&self.r#opening_hours_specification)
2863 })?;
2864 } else {
2865 serialize_struct.skip_field("openingHoursSpecification")?;
2866 }
2867 if !Vec::is_empty(&self.r#photo) {
2868 serialize_struct.serialize_field("photo", {
2869 struct SerializeWith<'a>(&'a Vec<PhotoProperty>);
2870 impl<'a> Serialize for SerializeWith<'a> {
2871 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2872 where
2873 S: Serializer,
2874 {
2875 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2876 self.0, serializer,
2877 )
2878 }
2879 }
2880 &SerializeWith(&self.r#photo)
2881 })?;
2882 } else {
2883 serialize_struct.skip_field("photo")?;
2884 }
2885 if !Vec::is_empty(&self.r#photos) {
2886 serialize_struct.serialize_field("photos", {
2887 struct SerializeWith<'a>(&'a Vec<PhotosProperty>);
2888 impl<'a> Serialize for SerializeWith<'a> {
2889 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2890 where
2891 S: Serializer,
2892 {
2893 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2894 self.0, serializer,
2895 )
2896 }
2897 }
2898 &SerializeWith(&self.r#photos)
2899 })?;
2900 } else {
2901 serialize_struct.skip_field("photos")?;
2902 }
2903 if !Vec::is_empty(&self.r#public_access) {
2904 serialize_struct.serialize_field("publicAccess", {
2905 struct SerializeWith<'a>(&'a Vec<PublicAccessProperty>);
2906 impl<'a> Serialize for SerializeWith<'a> {
2907 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2908 where
2909 S: Serializer,
2910 {
2911 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2912 self.0, serializer,
2913 )
2914 }
2915 }
2916 &SerializeWith(&self.r#public_access)
2917 })?;
2918 } else {
2919 serialize_struct.skip_field("publicAccess")?;
2920 }
2921 if !Vec::is_empty(&self.r#smoking_allowed) {
2922 serialize_struct.serialize_field("smokingAllowed", {
2923 struct SerializeWith<'a>(&'a Vec<SmokingAllowedProperty>);
2924 impl<'a> Serialize for SerializeWith<'a> {
2925 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2926 where
2927 S: Serializer,
2928 {
2929 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2930 self.0, serializer,
2931 )
2932 }
2933 }
2934 &SerializeWith(&self.r#smoking_allowed)
2935 })?;
2936 } else {
2937 serialize_struct.skip_field("smokingAllowed")?;
2938 }
2939 if !Vec::is_empty(&self.r#special_opening_hours_specification) {
2940 serialize_struct.serialize_field("specialOpeningHoursSpecification", {
2941 struct SerializeWith<'a>(&'a Vec<SpecialOpeningHoursSpecificationProperty>);
2942 impl<'a> Serialize for SerializeWith<'a> {
2943 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2944 where
2945 S: Serializer,
2946 {
2947 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2948 self.0, serializer,
2949 )
2950 }
2951 }
2952 &SerializeWith(&self.r#special_opening_hours_specification)
2953 })?;
2954 } else {
2955 serialize_struct.skip_field("specialOpeningHoursSpecification")?;
2956 }
2957 if !Vec::is_empty(&self.r#tour_booking_page) {
2958 serialize_struct.serialize_field("tourBookingPage", {
2959 struct SerializeWith<'a>(&'a Vec<TourBookingPageProperty>);
2960 impl<'a> Serialize for SerializeWith<'a> {
2961 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2962 where
2963 S: Serializer,
2964 {
2965 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2966 self.0, serializer,
2967 )
2968 }
2969 }
2970 &SerializeWith(&self.r#tour_booking_page)
2971 })?;
2972 } else {
2973 serialize_struct.skip_field("tourBookingPage")?;
2974 }
2975 if !Vec::is_empty(&self.r#additional_type) {
2976 serialize_struct.serialize_field("additionalType", {
2977 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
2978 impl<'a> Serialize for SerializeWith<'a> {
2979 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2980 where
2981 S: Serializer,
2982 {
2983 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2984 self.0, serializer,
2985 )
2986 }
2987 }
2988 &SerializeWith(&self.r#additional_type)
2989 })?;
2990 } else {
2991 serialize_struct.skip_field("additionalType")?;
2992 }
2993 if !Vec::is_empty(&self.r#alternate_name) {
2994 serialize_struct.serialize_field("alternateName", {
2995 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
2996 impl<'a> Serialize for SerializeWith<'a> {
2997 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2998 where
2999 S: Serializer,
3000 {
3001 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3002 self.0, serializer,
3003 )
3004 }
3005 }
3006 &SerializeWith(&self.r#alternate_name)
3007 })?;
3008 } else {
3009 serialize_struct.skip_field("alternateName")?;
3010 }
3011 if !Vec::is_empty(&self.r#description) {
3012 serialize_struct.serialize_field("description", {
3013 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
3014 impl<'a> Serialize for SerializeWith<'a> {
3015 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3016 where
3017 S: Serializer,
3018 {
3019 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3020 self.0, serializer,
3021 )
3022 }
3023 }
3024 &SerializeWith(&self.r#description)
3025 })?;
3026 } else {
3027 serialize_struct.skip_field("description")?;
3028 }
3029 if !Vec::is_empty(&self.r#disambiguating_description) {
3030 serialize_struct.serialize_field("disambiguatingDescription", {
3031 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
3032 impl<'a> Serialize for SerializeWith<'a> {
3033 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3034 where
3035 S: Serializer,
3036 {
3037 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3038 self.0, serializer,
3039 )
3040 }
3041 }
3042 &SerializeWith(&self.r#disambiguating_description)
3043 })?;
3044 } else {
3045 serialize_struct.skip_field("disambiguatingDescription")?;
3046 }
3047 if !Vec::is_empty(&self.r#identifier) {
3048 serialize_struct.serialize_field("identifier", {
3049 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
3050 impl<'a> Serialize for SerializeWith<'a> {
3051 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3052 where
3053 S: Serializer,
3054 {
3055 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3056 self.0, serializer,
3057 )
3058 }
3059 }
3060 &SerializeWith(&self.r#identifier)
3061 })?;
3062 } else {
3063 serialize_struct.skip_field("identifier")?;
3064 }
3065 if !Vec::is_empty(&self.r#image) {
3066 serialize_struct.serialize_field("image", {
3067 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
3068 impl<'a> Serialize for SerializeWith<'a> {
3069 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3070 where
3071 S: Serializer,
3072 {
3073 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3074 self.0, serializer,
3075 )
3076 }
3077 }
3078 &SerializeWith(&self.r#image)
3079 })?;
3080 } else {
3081 serialize_struct.skip_field("image")?;
3082 }
3083 if !Vec::is_empty(&self.r#main_entity_of_page) {
3084 serialize_struct.serialize_field("mainEntityOfPage", {
3085 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
3086 impl<'a> Serialize for SerializeWith<'a> {
3087 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3088 where
3089 S: Serializer,
3090 {
3091 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3092 self.0, serializer,
3093 )
3094 }
3095 }
3096 &SerializeWith(&self.r#main_entity_of_page)
3097 })?;
3098 } else {
3099 serialize_struct.skip_field("mainEntityOfPage")?;
3100 }
3101 if !Vec::is_empty(&self.r#name) {
3102 serialize_struct.serialize_field("name", {
3103 struct SerializeWith<'a>(&'a Vec<NameProperty>);
3104 impl<'a> Serialize for SerializeWith<'a> {
3105 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3106 where
3107 S: Serializer,
3108 {
3109 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3110 self.0, serializer,
3111 )
3112 }
3113 }
3114 &SerializeWith(&self.r#name)
3115 })?;
3116 } else {
3117 serialize_struct.skip_field("name")?;
3118 }
3119 if !Vec::is_empty(&self.r#potential_action) {
3120 serialize_struct.serialize_field("potentialAction", {
3121 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
3122 impl<'a> Serialize for SerializeWith<'a> {
3123 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3124 where
3125 S: Serializer,
3126 {
3127 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3128 self.0, serializer,
3129 )
3130 }
3131 }
3132 &SerializeWith(&self.r#potential_action)
3133 })?;
3134 } else {
3135 serialize_struct.skip_field("potentialAction")?;
3136 }
3137 if !Vec::is_empty(&self.r#same_as) {
3138 serialize_struct.serialize_field("sameAs", {
3139 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
3140 impl<'a> Serialize for SerializeWith<'a> {
3141 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3142 where
3143 S: Serializer,
3144 {
3145 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3146 self.0, serializer,
3147 )
3148 }
3149 }
3150 &SerializeWith(&self.r#same_as)
3151 })?;
3152 } else {
3153 serialize_struct.skip_field("sameAs")?;
3154 }
3155 if !Vec::is_empty(&self.r#subject_of) {
3156 serialize_struct.serialize_field("subjectOf", {
3157 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
3158 impl<'a> Serialize for SerializeWith<'a> {
3159 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3160 where
3161 S: Serializer,
3162 {
3163 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3164 self.0, serializer,
3165 )
3166 }
3167 }
3168 &SerializeWith(&self.r#subject_of)
3169 })?;
3170 } else {
3171 serialize_struct.skip_field("subjectOf")?;
3172 }
3173 if !Vec::is_empty(&self.r#url) {
3174 serialize_struct.serialize_field("url", {
3175 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
3176 impl<'a> Serialize for SerializeWith<'a> {
3177 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3178 where
3179 S: Serializer,
3180 {
3181 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3182 self.0, serializer,
3183 )
3184 }
3185 }
3186 &SerializeWith(&self.r#url)
3187 })?;
3188 } else {
3189 serialize_struct.skip_field("url")?;
3190 }
3191 serialize_struct.end()
3192 }
3193 }
3194 impl<'de> Deserialize<'de> for Preschool {
3195 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3196 where
3197 D: Deserializer<'de>,
3198 {
3199 enum Field {
3200 OpeningHours,
3201 Alumni,
3202 ActionableFeedbackPolicy,
3203 Address,
3204 AgentInteractionStatistic,
3205 AggregateRating,
3206 AreaServed,
3207 Award,
3208 Awards,
3209 Brand,
3210 ContactPoint,
3211 ContactPoints,
3212 CorrectionsPolicy,
3213 Department,
3214 DissolutionDate,
3215 DiversityPolicy,
3216 DiversityStaffingReport,
3217 Duns,
3218 Email,
3219 Employee,
3220 Employees,
3221 EthicsPolicy,
3222 Event,
3223 Events,
3224 FaxNumber,
3225 Founder,
3226 Founders,
3227 FoundingDate,
3228 FoundingLocation,
3229 Funder,
3230 Funding,
3231 GlobalLocationNumber,
3232 HasCredential,
3233 HasMerchantReturnPolicy,
3234 HasOfferCatalog,
3235 HasPos,
3236 HasProductReturnPolicy,
3237 InteractionStatistic,
3238 IsicV4,
3239 Iso6523Code,
3240 Keywords,
3241 KnowsAbout,
3242 KnowsLanguage,
3243 LegalName,
3244 LeiCode,
3245 Location,
3246 Logo,
3247 MakesOffer,
3248 Member,
3249 MemberOf,
3250 Members,
3251 Naics,
3252 NonprofitStatus,
3253 NumberOfEmployees,
3254 OwnershipFundingInfo,
3255 Owns,
3256 ParentOrganization,
3257 PublishingPrinciples,
3258 Review,
3259 Reviews,
3260 Seeks,
3261 ServiceArea,
3262 Slogan,
3263 Sponsor,
3264 SubOrganization,
3265 TaxId,
3266 Telephone,
3267 UnnamedSourcesPolicy,
3268 VatId,
3269 AdditionalProperty,
3270 AmenityFeature,
3271 BranchCode,
3272 ContainedIn,
3273 ContainedInPlace,
3274 ContainsPlace,
3275 Geo,
3276 GeoContains,
3277 GeoCoveredBy,
3278 GeoCovers,
3279 GeoCrosses,
3280 GeoDisjoint,
3281 GeoEquals,
3282 GeoIntersects,
3283 GeoOverlaps,
3284 GeoTouches,
3285 GeoWithin,
3286 HasDriveThroughService,
3287 HasMap,
3288 IsAccessibleForFree,
3289 Latitude,
3290 Longitude,
3291 Map,
3292 Maps,
3293 MaximumAttendeeCapacity,
3294 OpeningHoursSpecification,
3295 Photo,
3296 Photos,
3297 PublicAccess,
3298 SmokingAllowed,
3299 SpecialOpeningHoursSpecification,
3300 TourBookingPage,
3301 AdditionalType,
3302 AlternateName,
3303 Description,
3304 DisambiguatingDescription,
3305 Identifier,
3306 Image,
3307 MainEntityOfPage,
3308 Name,
3309 PotentialAction,
3310 SameAs,
3311 SubjectOf,
3312 Url,
3313 Ignore,
3314 }
3315 struct FieldVisitor;
3316 impl<'de> Visitor<'de> for FieldVisitor {
3317 type Value = Field;
3318 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
3319 formatter.write_str("field identifier")
3320 }
3321 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
3322 where
3323 E: de::Error,
3324 {
3325 match value {
3326 "openingHours" => Ok(Field::OpeningHours),
3327 "alumni" => Ok(Field::Alumni),
3328 "actionableFeedbackPolicy" => Ok(Field::ActionableFeedbackPolicy),
3329 "address" => Ok(Field::Address),
3330 "agentInteractionStatistic" => Ok(Field::AgentInteractionStatistic),
3331 "aggregateRating" => Ok(Field::AggregateRating),
3332 "areaServed" => Ok(Field::AreaServed),
3333 "award" => Ok(Field::Award),
3334 "awards" => Ok(Field::Awards),
3335 "brand" => Ok(Field::Brand),
3336 "contactPoint" => Ok(Field::ContactPoint),
3337 "contactPoints" => Ok(Field::ContactPoints),
3338 "correctionsPolicy" => Ok(Field::CorrectionsPolicy),
3339 "department" => Ok(Field::Department),
3340 "dissolutionDate" => Ok(Field::DissolutionDate),
3341 "diversityPolicy" => Ok(Field::DiversityPolicy),
3342 "diversityStaffingReport" => Ok(Field::DiversityStaffingReport),
3343 "duns" => Ok(Field::Duns),
3344 "email" => Ok(Field::Email),
3345 "employee" => Ok(Field::Employee),
3346 "employees" => Ok(Field::Employees),
3347 "ethicsPolicy" => Ok(Field::EthicsPolicy),
3348 "event" => Ok(Field::Event),
3349 "events" => Ok(Field::Events),
3350 "faxNumber" => Ok(Field::FaxNumber),
3351 "founder" => Ok(Field::Founder),
3352 "founders" => Ok(Field::Founders),
3353 "foundingDate" => Ok(Field::FoundingDate),
3354 "foundingLocation" => Ok(Field::FoundingLocation),
3355 "funder" => Ok(Field::Funder),
3356 "funding" => Ok(Field::Funding),
3357 "globalLocationNumber" => Ok(Field::GlobalLocationNumber),
3358 "hasCredential" => Ok(Field::HasCredential),
3359 "hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
3360 "hasOfferCatalog" => Ok(Field::HasOfferCatalog),
3361 "hasPOS" => Ok(Field::HasPos),
3362 "hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
3363 "interactionStatistic" => Ok(Field::InteractionStatistic),
3364 "isicV4" => Ok(Field::IsicV4),
3365 "iso6523Code" => Ok(Field::Iso6523Code),
3366 "keywords" => Ok(Field::Keywords),
3367 "knowsAbout" => Ok(Field::KnowsAbout),
3368 "knowsLanguage" => Ok(Field::KnowsLanguage),
3369 "legalName" => Ok(Field::LegalName),
3370 "leiCode" => Ok(Field::LeiCode),
3371 "location" => Ok(Field::Location),
3372 "logo" => Ok(Field::Logo),
3373 "makesOffer" => Ok(Field::MakesOffer),
3374 "member" => Ok(Field::Member),
3375 "memberOf" => Ok(Field::MemberOf),
3376 "members" => Ok(Field::Members),
3377 "naics" => Ok(Field::Naics),
3378 "nonprofitStatus" => Ok(Field::NonprofitStatus),
3379 "numberOfEmployees" => Ok(Field::NumberOfEmployees),
3380 "ownershipFundingInfo" => Ok(Field::OwnershipFundingInfo),
3381 "owns" => Ok(Field::Owns),
3382 "parentOrganization" => Ok(Field::ParentOrganization),
3383 "publishingPrinciples" => Ok(Field::PublishingPrinciples),
3384 "review" => Ok(Field::Review),
3385 "reviews" => Ok(Field::Reviews),
3386 "seeks" => Ok(Field::Seeks),
3387 "serviceArea" => Ok(Field::ServiceArea),
3388 "slogan" => Ok(Field::Slogan),
3389 "sponsor" => Ok(Field::Sponsor),
3390 "subOrganization" => Ok(Field::SubOrganization),
3391 "taxID" => Ok(Field::TaxId),
3392 "telephone" => Ok(Field::Telephone),
3393 "unnamedSourcesPolicy" => Ok(Field::UnnamedSourcesPolicy),
3394 "vatID" => Ok(Field::VatId),
3395 "additionalProperty" => Ok(Field::AdditionalProperty),
3396 "amenityFeature" => Ok(Field::AmenityFeature),
3397 "branchCode" => Ok(Field::BranchCode),
3398 "containedIn" => Ok(Field::ContainedIn),
3399 "containedInPlace" => Ok(Field::ContainedInPlace),
3400 "containsPlace" => Ok(Field::ContainsPlace),
3401 "geo" => Ok(Field::Geo),
3402 "geoContains" => Ok(Field::GeoContains),
3403 "geoCoveredBy" => Ok(Field::GeoCoveredBy),
3404 "geoCovers" => Ok(Field::GeoCovers),
3405 "geoCrosses" => Ok(Field::GeoCrosses),
3406 "geoDisjoint" => Ok(Field::GeoDisjoint),
3407 "geoEquals" => Ok(Field::GeoEquals),
3408 "geoIntersects" => Ok(Field::GeoIntersects),
3409 "geoOverlaps" => Ok(Field::GeoOverlaps),
3410 "geoTouches" => Ok(Field::GeoTouches),
3411 "geoWithin" => Ok(Field::GeoWithin),
3412 "hasDriveThroughService" => Ok(Field::HasDriveThroughService),
3413 "hasMap" => Ok(Field::HasMap),
3414 "isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
3415 "latitude" => Ok(Field::Latitude),
3416 "longitude" => Ok(Field::Longitude),
3417 "map" => Ok(Field::Map),
3418 "maps" => Ok(Field::Maps),
3419 "maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
3420 "openingHoursSpecification" => Ok(Field::OpeningHoursSpecification),
3421 "photo" => Ok(Field::Photo),
3422 "photos" => Ok(Field::Photos),
3423 "publicAccess" => Ok(Field::PublicAccess),
3424 "smokingAllowed" => Ok(Field::SmokingAllowed),
3425 "specialOpeningHoursSpecification" => {
3426 Ok(Field::SpecialOpeningHoursSpecification)
3427 }
3428 "tourBookingPage" => Ok(Field::TourBookingPage),
3429 "additionalType" => Ok(Field::AdditionalType),
3430 "alternateName" => Ok(Field::AlternateName),
3431 "description" => Ok(Field::Description),
3432 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
3433 "identifier" => Ok(Field::Identifier),
3434 "image" => Ok(Field::Image),
3435 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
3436 "name" => Ok(Field::Name),
3437 "potentialAction" => Ok(Field::PotentialAction),
3438 "sameAs" => Ok(Field::SameAs),
3439 "subjectOf" => Ok(Field::SubjectOf),
3440 "url" => Ok(Field::Url),
3441 "id" | "type" => Ok(Field::Ignore),
3442 _ => Err(de::Error::unknown_field(value, FIELDS)),
3443 }
3444 }
3445 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
3446 where
3447 E: de::Error,
3448 {
3449 match value {
3450 b"openingHours" => Ok(Field::OpeningHours),
3451 b"alumni" => Ok(Field::Alumni),
3452 b"actionableFeedbackPolicy" => Ok(Field::ActionableFeedbackPolicy),
3453 b"address" => Ok(Field::Address),
3454 b"agentInteractionStatistic" => Ok(Field::AgentInteractionStatistic),
3455 b"aggregateRating" => Ok(Field::AggregateRating),
3456 b"areaServed" => Ok(Field::AreaServed),
3457 b"award" => Ok(Field::Award),
3458 b"awards" => Ok(Field::Awards),
3459 b"brand" => Ok(Field::Brand),
3460 b"contactPoint" => Ok(Field::ContactPoint),
3461 b"contactPoints" => Ok(Field::ContactPoints),
3462 b"correctionsPolicy" => Ok(Field::CorrectionsPolicy),
3463 b"department" => Ok(Field::Department),
3464 b"dissolutionDate" => Ok(Field::DissolutionDate),
3465 b"diversityPolicy" => Ok(Field::DiversityPolicy),
3466 b"diversityStaffingReport" => Ok(Field::DiversityStaffingReport),
3467 b"duns" => Ok(Field::Duns),
3468 b"email" => Ok(Field::Email),
3469 b"employee" => Ok(Field::Employee),
3470 b"employees" => Ok(Field::Employees),
3471 b"ethicsPolicy" => Ok(Field::EthicsPolicy),
3472 b"event" => Ok(Field::Event),
3473 b"events" => Ok(Field::Events),
3474 b"faxNumber" => Ok(Field::FaxNumber),
3475 b"founder" => Ok(Field::Founder),
3476 b"founders" => Ok(Field::Founders),
3477 b"foundingDate" => Ok(Field::FoundingDate),
3478 b"foundingLocation" => Ok(Field::FoundingLocation),
3479 b"funder" => Ok(Field::Funder),
3480 b"funding" => Ok(Field::Funding),
3481 b"globalLocationNumber" => Ok(Field::GlobalLocationNumber),
3482 b"hasCredential" => Ok(Field::HasCredential),
3483 b"hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
3484 b"hasOfferCatalog" => Ok(Field::HasOfferCatalog),
3485 b"hasPOS" => Ok(Field::HasPos),
3486 b"hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
3487 b"interactionStatistic" => Ok(Field::InteractionStatistic),
3488 b"isicV4" => Ok(Field::IsicV4),
3489 b"iso6523Code" => Ok(Field::Iso6523Code),
3490 b"keywords" => Ok(Field::Keywords),
3491 b"knowsAbout" => Ok(Field::KnowsAbout),
3492 b"knowsLanguage" => Ok(Field::KnowsLanguage),
3493 b"legalName" => Ok(Field::LegalName),
3494 b"leiCode" => Ok(Field::LeiCode),
3495 b"location" => Ok(Field::Location),
3496 b"logo" => Ok(Field::Logo),
3497 b"makesOffer" => Ok(Field::MakesOffer),
3498 b"member" => Ok(Field::Member),
3499 b"memberOf" => Ok(Field::MemberOf),
3500 b"members" => Ok(Field::Members),
3501 b"naics" => Ok(Field::Naics),
3502 b"nonprofitStatus" => Ok(Field::NonprofitStatus),
3503 b"numberOfEmployees" => Ok(Field::NumberOfEmployees),
3504 b"ownershipFundingInfo" => Ok(Field::OwnershipFundingInfo),
3505 b"owns" => Ok(Field::Owns),
3506 b"parentOrganization" => Ok(Field::ParentOrganization),
3507 b"publishingPrinciples" => Ok(Field::PublishingPrinciples),
3508 b"review" => Ok(Field::Review),
3509 b"reviews" => Ok(Field::Reviews),
3510 b"seeks" => Ok(Field::Seeks),
3511 b"serviceArea" => Ok(Field::ServiceArea),
3512 b"slogan" => Ok(Field::Slogan),
3513 b"sponsor" => Ok(Field::Sponsor),
3514 b"subOrganization" => Ok(Field::SubOrganization),
3515 b"taxID" => Ok(Field::TaxId),
3516 b"telephone" => Ok(Field::Telephone),
3517 b"unnamedSourcesPolicy" => Ok(Field::UnnamedSourcesPolicy),
3518 b"vatID" => Ok(Field::VatId),
3519 b"additionalProperty" => Ok(Field::AdditionalProperty),
3520 b"amenityFeature" => Ok(Field::AmenityFeature),
3521 b"branchCode" => Ok(Field::BranchCode),
3522 b"containedIn" => Ok(Field::ContainedIn),
3523 b"containedInPlace" => Ok(Field::ContainedInPlace),
3524 b"containsPlace" => Ok(Field::ContainsPlace),
3525 b"geo" => Ok(Field::Geo),
3526 b"geoContains" => Ok(Field::GeoContains),
3527 b"geoCoveredBy" => Ok(Field::GeoCoveredBy),
3528 b"geoCovers" => Ok(Field::GeoCovers),
3529 b"geoCrosses" => Ok(Field::GeoCrosses),
3530 b"geoDisjoint" => Ok(Field::GeoDisjoint),
3531 b"geoEquals" => Ok(Field::GeoEquals),
3532 b"geoIntersects" => Ok(Field::GeoIntersects),
3533 b"geoOverlaps" => Ok(Field::GeoOverlaps),
3534 b"geoTouches" => Ok(Field::GeoTouches),
3535 b"geoWithin" => Ok(Field::GeoWithin),
3536 b"hasDriveThroughService" => Ok(Field::HasDriveThroughService),
3537 b"hasMap" => Ok(Field::HasMap),
3538 b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
3539 b"latitude" => Ok(Field::Latitude),
3540 b"longitude" => Ok(Field::Longitude),
3541 b"map" => Ok(Field::Map),
3542 b"maps" => Ok(Field::Maps),
3543 b"maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
3544 b"openingHoursSpecification" => Ok(Field::OpeningHoursSpecification),
3545 b"photo" => Ok(Field::Photo),
3546 b"photos" => Ok(Field::Photos),
3547 b"publicAccess" => Ok(Field::PublicAccess),
3548 b"smokingAllowed" => Ok(Field::SmokingAllowed),
3549 b"specialOpeningHoursSpecification" => {
3550 Ok(Field::SpecialOpeningHoursSpecification)
3551 }
3552 b"tourBookingPage" => Ok(Field::TourBookingPage),
3553 b"additionalType" => Ok(Field::AdditionalType),
3554 b"alternateName" => Ok(Field::AlternateName),
3555 b"description" => Ok(Field::Description),
3556 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
3557 b"identifier" => Ok(Field::Identifier),
3558 b"image" => Ok(Field::Image),
3559 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
3560 b"name" => Ok(Field::Name),
3561 b"potentialAction" => Ok(Field::PotentialAction),
3562 b"sameAs" => Ok(Field::SameAs),
3563 b"subjectOf" => Ok(Field::SubjectOf),
3564 b"url" => Ok(Field::Url),
3565 b"id" | b"type" => Ok(Field::Ignore),
3566 _ => {
3567 let value = &String::from_utf8_lossy(value);
3568 Err(de::Error::unknown_field(value, FIELDS))
3569 }
3570 }
3571 }
3572 }
3573 impl<'de> Deserialize<'de> for Field {
3574 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3575 where
3576 D: Deserializer<'de>,
3577 {
3578 deserializer.deserialize_identifier(FieldVisitor)
3579 }
3580 }
3581 struct ClassVisitor;
3582 impl<'de> Visitor<'de> for ClassVisitor {
3583 type Value = Preschool;
3584 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
3585 formatter.write_str("schema.org schema Preschool")
3586 }
3587 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
3588 where
3589 A: de::MapAccess<'de>,
3590 {
3591 let mut r#opening_hours_property = None;
3592 let mut r#alumni_property = None;
3593 let mut r#actionable_feedback_policy_property = None;
3594 let mut r#address_property = None;
3595 let mut r#agent_interaction_statistic_property = None;
3596 let mut r#aggregate_rating_property = None;
3597 let mut r#area_served_property = None;
3598 let mut r#award_property = None;
3599 let mut r#awards_property = None;
3600 let mut r#brand_property = None;
3601 let mut r#contact_point_property = None;
3602 let mut r#contact_points_property = None;
3603 let mut r#corrections_policy_property = None;
3604 let mut r#department_property = None;
3605 let mut r#dissolution_date_property = None;
3606 let mut r#diversity_policy_property = None;
3607 let mut r#diversity_staffing_report_property = None;
3608 let mut r#duns_property = None;
3609 let mut r#email_property = None;
3610 let mut r#employee_property = None;
3611 let mut r#employees_property = None;
3612 let mut r#ethics_policy_property = None;
3613 let mut r#event_property = None;
3614 let mut r#events_property = None;
3615 let mut r#fax_number_property = None;
3616 let mut r#founder_property = None;
3617 let mut r#founders_property = None;
3618 let mut r#founding_date_property = None;
3619 let mut r#founding_location_property = None;
3620 let mut r#funder_property = None;
3621 let mut r#funding_property = None;
3622 let mut r#global_location_number_property = None;
3623 let mut r#has_credential_property = None;
3624 let mut r#has_merchant_return_policy_property = None;
3625 let mut r#has_offer_catalog_property = None;
3626 let mut r#has_pos_property = None;
3627 let mut r#has_product_return_policy_property = None;
3628 let mut r#interaction_statistic_property = None;
3629 let mut r#isic_v_4_property = None;
3630 let mut r#iso_6523_code_property = None;
3631 let mut r#keywords_property = None;
3632 let mut r#knows_about_property = None;
3633 let mut r#knows_language_property = None;
3634 let mut r#legal_name_property = None;
3635 let mut r#lei_code_property = None;
3636 let mut r#location_property = None;
3637 let mut r#logo_property = None;
3638 let mut r#makes_offer_property = None;
3639 let mut r#member_property = None;
3640 let mut r#member_of_property = None;
3641 let mut r#members_property = None;
3642 let mut r#naics_property = None;
3643 let mut r#nonprofit_status_property = None;
3644 let mut r#number_of_employees_property = None;
3645 let mut r#ownership_funding_info_property = None;
3646 let mut r#owns_property = None;
3647 let mut r#parent_organization_property = None;
3648 let mut r#publishing_principles_property = None;
3649 let mut r#review_property = None;
3650 let mut r#reviews_property = None;
3651 let mut r#seeks_property = None;
3652 let mut r#service_area_property = None;
3653 let mut r#slogan_property = None;
3654 let mut r#sponsor_property = None;
3655 let mut r#sub_organization_property = None;
3656 let mut r#tax_id_property = None;
3657 let mut r#telephone_property = None;
3658 let mut r#unnamed_sources_policy_property = None;
3659 let mut r#vat_id_property = None;
3660 let mut r#additional_property_property = None;
3661 let mut r#amenity_feature_property = None;
3662 let mut r#branch_code_property = None;
3663 let mut r#contained_in_property = None;
3664 let mut r#contained_in_place_property = None;
3665 let mut r#contains_place_property = None;
3666 let mut r#geo_property = None;
3667 let mut r#geo_contains_property = None;
3668 let mut r#geo_covered_by_property = None;
3669 let mut r#geo_covers_property = None;
3670 let mut r#geo_crosses_property = None;
3671 let mut r#geo_disjoint_property = None;
3672 let mut r#geo_equals_property = None;
3673 let mut r#geo_intersects_property = None;
3674 let mut r#geo_overlaps_property = None;
3675 let mut r#geo_touches_property = None;
3676 let mut r#geo_within_property = None;
3677 let mut r#has_drive_through_service_property = None;
3678 let mut r#has_map_property = None;
3679 let mut r#is_accessible_for_free_property = None;
3680 let mut r#latitude_property = None;
3681 let mut r#longitude_property = None;
3682 let mut r#map_property = None;
3683 let mut r#maps_property = None;
3684 let mut r#maximum_attendee_capacity_property = None;
3685 let mut r#opening_hours_specification_property = None;
3686 let mut r#photo_property = None;
3687 let mut r#photos_property = None;
3688 let mut r#public_access_property = None;
3689 let mut r#smoking_allowed_property = None;
3690 let mut r#special_opening_hours_specification_property = None;
3691 let mut r#tour_booking_page_property = None;
3692 let mut r#additional_type_property = None;
3693 let mut r#alternate_name_property = None;
3694 let mut r#description_property = None;
3695 let mut r#disambiguating_description_property = None;
3696 let mut r#identifier_property = None;
3697 let mut r#image_property = None;
3698 let mut r#main_entity_of_page_property = None;
3699 let mut r#name_property = None;
3700 let mut r#potential_action_property = None;
3701 let mut r#same_as_property = None;
3702 let mut r#subject_of_property = None;
3703 let mut r#url_property = None;
3704 while let Some(key) = map.next_key::<Field>()? {
3705 match key {
3706 Field::OpeningHours => {
3707 if r#opening_hours_property.is_some() {
3708 return Err(<A::Error as de::Error>::duplicate_field(
3709 "openingHours",
3710 ));
3711 }
3712 r#opening_hours_property = Some({
3713 struct DeserializeWith(Vec<OpeningHoursProperty>);
3714 impl<'de> Deserialize<'de> for DeserializeWith {
3715 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3716 where
3717 D: Deserializer<'de>,
3718 {
3719 Ok(DeserializeWith(serde_with::As::<
3720 serde_with::OneOrMany<serde_with::Same>,
3721 >::deserialize(deserializer)?))
3722 }
3723 }
3724 match map.next_value::<DeserializeWith>() {
3725 Ok(deserialize_with) => deserialize_with.0,
3726 Err(err) => {
3727 return Err(err);
3728 }
3729 }
3730 });
3731 }
3732 Field::Alumni => {
3733 if r#alumni_property.is_some() {
3734 return Err(<A::Error as de::Error>::duplicate_field("alumni"));
3735 }
3736 r#alumni_property = Some({
3737 struct DeserializeWith(Vec<AlumniProperty>);
3738 impl<'de> Deserialize<'de> for DeserializeWith {
3739 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3740 where
3741 D: Deserializer<'de>,
3742 {
3743 Ok(DeserializeWith(serde_with::As::<
3744 serde_with::OneOrMany<serde_with::Same>,
3745 >::deserialize(deserializer)?))
3746 }
3747 }
3748 match map.next_value::<DeserializeWith>() {
3749 Ok(deserialize_with) => deserialize_with.0,
3750 Err(err) => {
3751 return Err(err);
3752 }
3753 }
3754 });
3755 }
3756 Field::ActionableFeedbackPolicy => {
3757 if r#actionable_feedback_policy_property.is_some() {
3758 return Err(<A::Error as de::Error>::duplicate_field(
3759 "actionableFeedbackPolicy",
3760 ));
3761 }
3762 r#actionable_feedback_policy_property = Some({
3763 struct DeserializeWith(Vec<ActionableFeedbackPolicyProperty>);
3764 impl<'de> Deserialize<'de> for DeserializeWith {
3765 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3766 where
3767 D: Deserializer<'de>,
3768 {
3769 Ok(DeserializeWith(serde_with::As::<
3770 serde_with::OneOrMany<serde_with::Same>,
3771 >::deserialize(deserializer)?))
3772 }
3773 }
3774 match map.next_value::<DeserializeWith>() {
3775 Ok(deserialize_with) => deserialize_with.0,
3776 Err(err) => {
3777 return Err(err);
3778 }
3779 }
3780 });
3781 }
3782 Field::Address => {
3783 if r#address_property.is_some() {
3784 return Err(<A::Error as de::Error>::duplicate_field(
3785 "address",
3786 ));
3787 }
3788 r#address_property = Some({
3789 struct DeserializeWith(Vec<AddressProperty>);
3790 impl<'de> Deserialize<'de> for DeserializeWith {
3791 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3792 where
3793 D: Deserializer<'de>,
3794 {
3795 Ok(DeserializeWith(serde_with::As::<
3796 serde_with::OneOrMany<serde_with::Same>,
3797 >::deserialize(deserializer)?))
3798 }
3799 }
3800 match map.next_value::<DeserializeWith>() {
3801 Ok(deserialize_with) => deserialize_with.0,
3802 Err(err) => {
3803 return Err(err);
3804 }
3805 }
3806 });
3807 }
3808 Field::AgentInteractionStatistic => {
3809 if r#agent_interaction_statistic_property.is_some() {
3810 return Err(<A::Error as de::Error>::duplicate_field(
3811 "agentInteractionStatistic",
3812 ));
3813 }
3814 r#agent_interaction_statistic_property = Some({
3815 struct DeserializeWith(Vec<AgentInteractionStatisticProperty>);
3816 impl<'de> Deserialize<'de> for DeserializeWith {
3817 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3818 where
3819 D: Deserializer<'de>,
3820 {
3821 Ok(DeserializeWith(serde_with::As::<
3822 serde_with::OneOrMany<serde_with::Same>,
3823 >::deserialize(deserializer)?))
3824 }
3825 }
3826 match map.next_value::<DeserializeWith>() {
3827 Ok(deserialize_with) => deserialize_with.0,
3828 Err(err) => {
3829 return Err(err);
3830 }
3831 }
3832 });
3833 }
3834 Field::AggregateRating => {
3835 if r#aggregate_rating_property.is_some() {
3836 return Err(<A::Error as de::Error>::duplicate_field(
3837 "aggregateRating",
3838 ));
3839 }
3840 r#aggregate_rating_property = Some({
3841 struct DeserializeWith(Vec<AggregateRatingProperty>);
3842 impl<'de> Deserialize<'de> for DeserializeWith {
3843 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3844 where
3845 D: Deserializer<'de>,
3846 {
3847 Ok(DeserializeWith(serde_with::As::<
3848 serde_with::OneOrMany<serde_with::Same>,
3849 >::deserialize(deserializer)?))
3850 }
3851 }
3852 match map.next_value::<DeserializeWith>() {
3853 Ok(deserialize_with) => deserialize_with.0,
3854 Err(err) => {
3855 return Err(err);
3856 }
3857 }
3858 });
3859 }
3860 Field::AreaServed => {
3861 if r#area_served_property.is_some() {
3862 return Err(<A::Error as de::Error>::duplicate_field(
3863 "areaServed",
3864 ));
3865 }
3866 r#area_served_property = Some({
3867 struct DeserializeWith(Vec<AreaServedProperty>);
3868 impl<'de> Deserialize<'de> for DeserializeWith {
3869 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3870 where
3871 D: Deserializer<'de>,
3872 {
3873 Ok(DeserializeWith(serde_with::As::<
3874 serde_with::OneOrMany<serde_with::Same>,
3875 >::deserialize(deserializer)?))
3876 }
3877 }
3878 match map.next_value::<DeserializeWith>() {
3879 Ok(deserialize_with) => deserialize_with.0,
3880 Err(err) => {
3881 return Err(err);
3882 }
3883 }
3884 });
3885 }
3886 Field::Award => {
3887 if r#award_property.is_some() {
3888 return Err(<A::Error as de::Error>::duplicate_field("award"));
3889 }
3890 r#award_property = Some({
3891 struct DeserializeWith(Vec<AwardProperty>);
3892 impl<'de> Deserialize<'de> for DeserializeWith {
3893 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3894 where
3895 D: Deserializer<'de>,
3896 {
3897 Ok(DeserializeWith(serde_with::As::<
3898 serde_with::OneOrMany<serde_with::Same>,
3899 >::deserialize(deserializer)?))
3900 }
3901 }
3902 match map.next_value::<DeserializeWith>() {
3903 Ok(deserialize_with) => deserialize_with.0,
3904 Err(err) => {
3905 return Err(err);
3906 }
3907 }
3908 });
3909 }
3910 Field::Awards => {
3911 if r#awards_property.is_some() {
3912 return Err(<A::Error as de::Error>::duplicate_field("awards"));
3913 }
3914 r#awards_property = Some({
3915 struct DeserializeWith(Vec<AwardsProperty>);
3916 impl<'de> Deserialize<'de> for DeserializeWith {
3917 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3918 where
3919 D: Deserializer<'de>,
3920 {
3921 Ok(DeserializeWith(serde_with::As::<
3922 serde_with::OneOrMany<serde_with::Same>,
3923 >::deserialize(deserializer)?))
3924 }
3925 }
3926 match map.next_value::<DeserializeWith>() {
3927 Ok(deserialize_with) => deserialize_with.0,
3928 Err(err) => {
3929 return Err(err);
3930 }
3931 }
3932 });
3933 }
3934 Field::Brand => {
3935 if r#brand_property.is_some() {
3936 return Err(<A::Error as de::Error>::duplicate_field("brand"));
3937 }
3938 r#brand_property = Some({
3939 struct DeserializeWith(Vec<BrandProperty>);
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::ContactPoint => {
3959 if r#contact_point_property.is_some() {
3960 return Err(<A::Error as de::Error>::duplicate_field(
3961 "contactPoint",
3962 ));
3963 }
3964 r#contact_point_property = Some({
3965 struct DeserializeWith(Vec<ContactPointProperty>);
3966 impl<'de> Deserialize<'de> for DeserializeWith {
3967 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3968 where
3969 D: Deserializer<'de>,
3970 {
3971 Ok(DeserializeWith(serde_with::As::<
3972 serde_with::OneOrMany<serde_with::Same>,
3973 >::deserialize(deserializer)?))
3974 }
3975 }
3976 match map.next_value::<DeserializeWith>() {
3977 Ok(deserialize_with) => deserialize_with.0,
3978 Err(err) => {
3979 return Err(err);
3980 }
3981 }
3982 });
3983 }
3984 Field::ContactPoints => {
3985 if r#contact_points_property.is_some() {
3986 return Err(<A::Error as de::Error>::duplicate_field(
3987 "contactPoints",
3988 ));
3989 }
3990 r#contact_points_property = Some({
3991 struct DeserializeWith(Vec<ContactPointsProperty>);
3992 impl<'de> Deserialize<'de> for DeserializeWith {
3993 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3994 where
3995 D: Deserializer<'de>,
3996 {
3997 Ok(DeserializeWith(serde_with::As::<
3998 serde_with::OneOrMany<serde_with::Same>,
3999 >::deserialize(deserializer)?))
4000 }
4001 }
4002 match map.next_value::<DeserializeWith>() {
4003 Ok(deserialize_with) => deserialize_with.0,
4004 Err(err) => {
4005 return Err(err);
4006 }
4007 }
4008 });
4009 }
4010 Field::CorrectionsPolicy => {
4011 if r#corrections_policy_property.is_some() {
4012 return Err(<A::Error as de::Error>::duplicate_field(
4013 "correctionsPolicy",
4014 ));
4015 }
4016 r#corrections_policy_property = Some({
4017 struct DeserializeWith(Vec<CorrectionsPolicyProperty>);
4018 impl<'de> Deserialize<'de> for DeserializeWith {
4019 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4020 where
4021 D: Deserializer<'de>,
4022 {
4023 Ok(DeserializeWith(serde_with::As::<
4024 serde_with::OneOrMany<serde_with::Same>,
4025 >::deserialize(deserializer)?))
4026 }
4027 }
4028 match map.next_value::<DeserializeWith>() {
4029 Ok(deserialize_with) => deserialize_with.0,
4030 Err(err) => {
4031 return Err(err);
4032 }
4033 }
4034 });
4035 }
4036 Field::Department => {
4037 if r#department_property.is_some() {
4038 return Err(<A::Error as de::Error>::duplicate_field(
4039 "department",
4040 ));
4041 }
4042 r#department_property = Some({
4043 struct DeserializeWith(Vec<DepartmentProperty>);
4044 impl<'de> Deserialize<'de> for DeserializeWith {
4045 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4046 where
4047 D: Deserializer<'de>,
4048 {
4049 Ok(DeserializeWith(serde_with::As::<
4050 serde_with::OneOrMany<serde_with::Same>,
4051 >::deserialize(deserializer)?))
4052 }
4053 }
4054 match map.next_value::<DeserializeWith>() {
4055 Ok(deserialize_with) => deserialize_with.0,
4056 Err(err) => {
4057 return Err(err);
4058 }
4059 }
4060 });
4061 }
4062 Field::DissolutionDate => {
4063 if r#dissolution_date_property.is_some() {
4064 return Err(<A::Error as de::Error>::duplicate_field(
4065 "dissolutionDate",
4066 ));
4067 }
4068 r#dissolution_date_property = Some({
4069 struct DeserializeWith(Vec<DissolutionDateProperty>);
4070 impl<'de> Deserialize<'de> for DeserializeWith {
4071 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4072 where
4073 D: Deserializer<'de>,
4074 {
4075 Ok(DeserializeWith(serde_with::As::<
4076 serde_with::OneOrMany<serde_with::Same>,
4077 >::deserialize(deserializer)?))
4078 }
4079 }
4080 match map.next_value::<DeserializeWith>() {
4081 Ok(deserialize_with) => deserialize_with.0,
4082 Err(err) => {
4083 return Err(err);
4084 }
4085 }
4086 });
4087 }
4088 Field::DiversityPolicy => {
4089 if r#diversity_policy_property.is_some() {
4090 return Err(<A::Error as de::Error>::duplicate_field(
4091 "diversityPolicy",
4092 ));
4093 }
4094 r#diversity_policy_property = Some({
4095 struct DeserializeWith(Vec<DiversityPolicyProperty>);
4096 impl<'de> Deserialize<'de> for DeserializeWith {
4097 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4098 where
4099 D: Deserializer<'de>,
4100 {
4101 Ok(DeserializeWith(serde_with::As::<
4102 serde_with::OneOrMany<serde_with::Same>,
4103 >::deserialize(deserializer)?))
4104 }
4105 }
4106 match map.next_value::<DeserializeWith>() {
4107 Ok(deserialize_with) => deserialize_with.0,
4108 Err(err) => {
4109 return Err(err);
4110 }
4111 }
4112 });
4113 }
4114 Field::DiversityStaffingReport => {
4115 if r#diversity_staffing_report_property.is_some() {
4116 return Err(<A::Error as de::Error>::duplicate_field(
4117 "diversityStaffingReport",
4118 ));
4119 }
4120 r#diversity_staffing_report_property = Some({
4121 struct DeserializeWith(Vec<DiversityStaffingReportProperty>);
4122 impl<'de> Deserialize<'de> for DeserializeWith {
4123 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4124 where
4125 D: Deserializer<'de>,
4126 {
4127 Ok(DeserializeWith(serde_with::As::<
4128 serde_with::OneOrMany<serde_with::Same>,
4129 >::deserialize(deserializer)?))
4130 }
4131 }
4132 match map.next_value::<DeserializeWith>() {
4133 Ok(deserialize_with) => deserialize_with.0,
4134 Err(err) => {
4135 return Err(err);
4136 }
4137 }
4138 });
4139 }
4140 Field::Duns => {
4141 if r#duns_property.is_some() {
4142 return Err(<A::Error as de::Error>::duplicate_field("duns"));
4143 }
4144 r#duns_property = Some({
4145 struct DeserializeWith(Vec<DunsProperty>);
4146 impl<'de> Deserialize<'de> for DeserializeWith {
4147 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4148 where
4149 D: Deserializer<'de>,
4150 {
4151 Ok(DeserializeWith(serde_with::As::<
4152 serde_with::OneOrMany<serde_with::Same>,
4153 >::deserialize(deserializer)?))
4154 }
4155 }
4156 match map.next_value::<DeserializeWith>() {
4157 Ok(deserialize_with) => deserialize_with.0,
4158 Err(err) => {
4159 return Err(err);
4160 }
4161 }
4162 });
4163 }
4164 Field::Email => {
4165 if r#email_property.is_some() {
4166 return Err(<A::Error as de::Error>::duplicate_field("email"));
4167 }
4168 r#email_property = Some({
4169 struct DeserializeWith(Vec<EmailProperty>);
4170 impl<'de> Deserialize<'de> for DeserializeWith {
4171 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4172 where
4173 D: Deserializer<'de>,
4174 {
4175 Ok(DeserializeWith(serde_with::As::<
4176 serde_with::OneOrMany<serde_with::Same>,
4177 >::deserialize(deserializer)?))
4178 }
4179 }
4180 match map.next_value::<DeserializeWith>() {
4181 Ok(deserialize_with) => deserialize_with.0,
4182 Err(err) => {
4183 return Err(err);
4184 }
4185 }
4186 });
4187 }
4188 Field::Employee => {
4189 if r#employee_property.is_some() {
4190 return Err(<A::Error as de::Error>::duplicate_field(
4191 "employee",
4192 ));
4193 }
4194 r#employee_property = Some({
4195 struct DeserializeWith(Vec<EmployeeProperty>);
4196 impl<'de> Deserialize<'de> for DeserializeWith {
4197 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4198 where
4199 D: Deserializer<'de>,
4200 {
4201 Ok(DeserializeWith(serde_with::As::<
4202 serde_with::OneOrMany<serde_with::Same>,
4203 >::deserialize(deserializer)?))
4204 }
4205 }
4206 match map.next_value::<DeserializeWith>() {
4207 Ok(deserialize_with) => deserialize_with.0,
4208 Err(err) => {
4209 return Err(err);
4210 }
4211 }
4212 });
4213 }
4214 Field::Employees => {
4215 if r#employees_property.is_some() {
4216 return Err(<A::Error as de::Error>::duplicate_field(
4217 "employees",
4218 ));
4219 }
4220 r#employees_property = Some({
4221 struct DeserializeWith(Vec<EmployeesProperty>);
4222 impl<'de> Deserialize<'de> for DeserializeWith {
4223 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4224 where
4225 D: Deserializer<'de>,
4226 {
4227 Ok(DeserializeWith(serde_with::As::<
4228 serde_with::OneOrMany<serde_with::Same>,
4229 >::deserialize(deserializer)?))
4230 }
4231 }
4232 match map.next_value::<DeserializeWith>() {
4233 Ok(deserialize_with) => deserialize_with.0,
4234 Err(err) => {
4235 return Err(err);
4236 }
4237 }
4238 });
4239 }
4240 Field::EthicsPolicy => {
4241 if r#ethics_policy_property.is_some() {
4242 return Err(<A::Error as de::Error>::duplicate_field(
4243 "ethicsPolicy",
4244 ));
4245 }
4246 r#ethics_policy_property = Some({
4247 struct DeserializeWith(Vec<EthicsPolicyProperty>);
4248 impl<'de> Deserialize<'de> for DeserializeWith {
4249 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4250 where
4251 D: Deserializer<'de>,
4252 {
4253 Ok(DeserializeWith(serde_with::As::<
4254 serde_with::OneOrMany<serde_with::Same>,
4255 >::deserialize(deserializer)?))
4256 }
4257 }
4258 match map.next_value::<DeserializeWith>() {
4259 Ok(deserialize_with) => deserialize_with.0,
4260 Err(err) => {
4261 return Err(err);
4262 }
4263 }
4264 });
4265 }
4266 Field::Event => {
4267 if r#event_property.is_some() {
4268 return Err(<A::Error as de::Error>::duplicate_field("event"));
4269 }
4270 r#event_property = Some({
4271 struct DeserializeWith(Vec<EventProperty>);
4272 impl<'de> Deserialize<'de> for DeserializeWith {
4273 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4274 where
4275 D: Deserializer<'de>,
4276 {
4277 Ok(DeserializeWith(serde_with::As::<
4278 serde_with::OneOrMany<serde_with::Same>,
4279 >::deserialize(deserializer)?))
4280 }
4281 }
4282 match map.next_value::<DeserializeWith>() {
4283 Ok(deserialize_with) => deserialize_with.0,
4284 Err(err) => {
4285 return Err(err);
4286 }
4287 }
4288 });
4289 }
4290 Field::Events => {
4291 if r#events_property.is_some() {
4292 return Err(<A::Error as de::Error>::duplicate_field("events"));
4293 }
4294 r#events_property = Some({
4295 struct DeserializeWith(Vec<EventsProperty>);
4296 impl<'de> Deserialize<'de> for DeserializeWith {
4297 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4298 where
4299 D: Deserializer<'de>,
4300 {
4301 Ok(DeserializeWith(serde_with::As::<
4302 serde_with::OneOrMany<serde_with::Same>,
4303 >::deserialize(deserializer)?))
4304 }
4305 }
4306 match map.next_value::<DeserializeWith>() {
4307 Ok(deserialize_with) => deserialize_with.0,
4308 Err(err) => {
4309 return Err(err);
4310 }
4311 }
4312 });
4313 }
4314 Field::FaxNumber => {
4315 if r#fax_number_property.is_some() {
4316 return Err(<A::Error as de::Error>::duplicate_field(
4317 "faxNumber",
4318 ));
4319 }
4320 r#fax_number_property = Some({
4321 struct DeserializeWith(Vec<FaxNumberProperty>);
4322 impl<'de> Deserialize<'de> for DeserializeWith {
4323 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4324 where
4325 D: Deserializer<'de>,
4326 {
4327 Ok(DeserializeWith(serde_with::As::<
4328 serde_with::OneOrMany<serde_with::Same>,
4329 >::deserialize(deserializer)?))
4330 }
4331 }
4332 match map.next_value::<DeserializeWith>() {
4333 Ok(deserialize_with) => deserialize_with.0,
4334 Err(err) => {
4335 return Err(err);
4336 }
4337 }
4338 });
4339 }
4340 Field::Founder => {
4341 if r#founder_property.is_some() {
4342 return Err(<A::Error as de::Error>::duplicate_field(
4343 "founder",
4344 ));
4345 }
4346 r#founder_property = Some({
4347 struct DeserializeWith(Vec<FounderProperty>);
4348 impl<'de> Deserialize<'de> for DeserializeWith {
4349 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4350 where
4351 D: Deserializer<'de>,
4352 {
4353 Ok(DeserializeWith(serde_with::As::<
4354 serde_with::OneOrMany<serde_with::Same>,
4355 >::deserialize(deserializer)?))
4356 }
4357 }
4358 match map.next_value::<DeserializeWith>() {
4359 Ok(deserialize_with) => deserialize_with.0,
4360 Err(err) => {
4361 return Err(err);
4362 }
4363 }
4364 });
4365 }
4366 Field::Founders => {
4367 if r#founders_property.is_some() {
4368 return Err(<A::Error as de::Error>::duplicate_field(
4369 "founders",
4370 ));
4371 }
4372 r#founders_property = Some({
4373 struct DeserializeWith(Vec<FoundersProperty>);
4374 impl<'de> Deserialize<'de> for DeserializeWith {
4375 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4376 where
4377 D: Deserializer<'de>,
4378 {
4379 Ok(DeserializeWith(serde_with::As::<
4380 serde_with::OneOrMany<serde_with::Same>,
4381 >::deserialize(deserializer)?))
4382 }
4383 }
4384 match map.next_value::<DeserializeWith>() {
4385 Ok(deserialize_with) => deserialize_with.0,
4386 Err(err) => {
4387 return Err(err);
4388 }
4389 }
4390 });
4391 }
4392 Field::FoundingDate => {
4393 if r#founding_date_property.is_some() {
4394 return Err(<A::Error as de::Error>::duplicate_field(
4395 "foundingDate",
4396 ));
4397 }
4398 r#founding_date_property = Some({
4399 struct DeserializeWith(Vec<FoundingDateProperty>);
4400 impl<'de> Deserialize<'de> for DeserializeWith {
4401 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4402 where
4403 D: Deserializer<'de>,
4404 {
4405 Ok(DeserializeWith(serde_with::As::<
4406 serde_with::OneOrMany<serde_with::Same>,
4407 >::deserialize(deserializer)?))
4408 }
4409 }
4410 match map.next_value::<DeserializeWith>() {
4411 Ok(deserialize_with) => deserialize_with.0,
4412 Err(err) => {
4413 return Err(err);
4414 }
4415 }
4416 });
4417 }
4418 Field::FoundingLocation => {
4419 if r#founding_location_property.is_some() {
4420 return Err(<A::Error as de::Error>::duplicate_field(
4421 "foundingLocation",
4422 ));
4423 }
4424 r#founding_location_property = Some({
4425 struct DeserializeWith(Vec<FoundingLocationProperty>);
4426 impl<'de> Deserialize<'de> for DeserializeWith {
4427 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4428 where
4429 D: Deserializer<'de>,
4430 {
4431 Ok(DeserializeWith(serde_with::As::<
4432 serde_with::OneOrMany<serde_with::Same>,
4433 >::deserialize(deserializer)?))
4434 }
4435 }
4436 match map.next_value::<DeserializeWith>() {
4437 Ok(deserialize_with) => deserialize_with.0,
4438 Err(err) => {
4439 return Err(err);
4440 }
4441 }
4442 });
4443 }
4444 Field::Funder => {
4445 if r#funder_property.is_some() {
4446 return Err(<A::Error as de::Error>::duplicate_field("funder"));
4447 }
4448 r#funder_property = Some({
4449 struct DeserializeWith(Vec<FunderProperty>);
4450 impl<'de> Deserialize<'de> for DeserializeWith {
4451 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4452 where
4453 D: Deserializer<'de>,
4454 {
4455 Ok(DeserializeWith(serde_with::As::<
4456 serde_with::OneOrMany<serde_with::Same>,
4457 >::deserialize(deserializer)?))
4458 }
4459 }
4460 match map.next_value::<DeserializeWith>() {
4461 Ok(deserialize_with) => deserialize_with.0,
4462 Err(err) => {
4463 return Err(err);
4464 }
4465 }
4466 });
4467 }
4468 Field::Funding => {
4469 if r#funding_property.is_some() {
4470 return Err(<A::Error as de::Error>::duplicate_field(
4471 "funding",
4472 ));
4473 }
4474 r#funding_property = Some({
4475 struct DeserializeWith(Vec<FundingProperty>);
4476 impl<'de> Deserialize<'de> for DeserializeWith {
4477 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4478 where
4479 D: Deserializer<'de>,
4480 {
4481 Ok(DeserializeWith(serde_with::As::<
4482 serde_with::OneOrMany<serde_with::Same>,
4483 >::deserialize(deserializer)?))
4484 }
4485 }
4486 match map.next_value::<DeserializeWith>() {
4487 Ok(deserialize_with) => deserialize_with.0,
4488 Err(err) => {
4489 return Err(err);
4490 }
4491 }
4492 });
4493 }
4494 Field::GlobalLocationNumber => {
4495 if r#global_location_number_property.is_some() {
4496 return Err(<A::Error as de::Error>::duplicate_field(
4497 "globalLocationNumber",
4498 ));
4499 }
4500 r#global_location_number_property = Some({
4501 struct DeserializeWith(Vec<GlobalLocationNumberProperty>);
4502 impl<'de> Deserialize<'de> for DeserializeWith {
4503 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4504 where
4505 D: Deserializer<'de>,
4506 {
4507 Ok(DeserializeWith(serde_with::As::<
4508 serde_with::OneOrMany<serde_with::Same>,
4509 >::deserialize(deserializer)?))
4510 }
4511 }
4512 match map.next_value::<DeserializeWith>() {
4513 Ok(deserialize_with) => deserialize_with.0,
4514 Err(err) => {
4515 return Err(err);
4516 }
4517 }
4518 });
4519 }
4520 Field::HasCredential => {
4521 if r#has_credential_property.is_some() {
4522 return Err(<A::Error as de::Error>::duplicate_field(
4523 "hasCredential",
4524 ));
4525 }
4526 r#has_credential_property = Some({
4527 struct DeserializeWith(Vec<HasCredentialProperty>);
4528 impl<'de> Deserialize<'de> for DeserializeWith {
4529 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4530 where
4531 D: Deserializer<'de>,
4532 {
4533 Ok(DeserializeWith(serde_with::As::<
4534 serde_with::OneOrMany<serde_with::Same>,
4535 >::deserialize(deserializer)?))
4536 }
4537 }
4538 match map.next_value::<DeserializeWith>() {
4539 Ok(deserialize_with) => deserialize_with.0,
4540 Err(err) => {
4541 return Err(err);
4542 }
4543 }
4544 });
4545 }
4546 Field::HasMerchantReturnPolicy => {
4547 if r#has_merchant_return_policy_property.is_some() {
4548 return Err(<A::Error as de::Error>::duplicate_field(
4549 "hasMerchantReturnPolicy",
4550 ));
4551 }
4552 r#has_merchant_return_policy_property = Some({
4553 struct DeserializeWith(Vec<HasMerchantReturnPolicyProperty>);
4554 impl<'de> Deserialize<'de> for DeserializeWith {
4555 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4556 where
4557 D: Deserializer<'de>,
4558 {
4559 Ok(DeserializeWith(serde_with::As::<
4560 serde_with::OneOrMany<serde_with::Same>,
4561 >::deserialize(deserializer)?))
4562 }
4563 }
4564 match map.next_value::<DeserializeWith>() {
4565 Ok(deserialize_with) => deserialize_with.0,
4566 Err(err) => {
4567 return Err(err);
4568 }
4569 }
4570 });
4571 }
4572 Field::HasOfferCatalog => {
4573 if r#has_offer_catalog_property.is_some() {
4574 return Err(<A::Error as de::Error>::duplicate_field(
4575 "hasOfferCatalog",
4576 ));
4577 }
4578 r#has_offer_catalog_property = Some({
4579 struct DeserializeWith(Vec<HasOfferCatalogProperty>);
4580 impl<'de> Deserialize<'de> for DeserializeWith {
4581 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4582 where
4583 D: Deserializer<'de>,
4584 {
4585 Ok(DeserializeWith(serde_with::As::<
4586 serde_with::OneOrMany<serde_with::Same>,
4587 >::deserialize(deserializer)?))
4588 }
4589 }
4590 match map.next_value::<DeserializeWith>() {
4591 Ok(deserialize_with) => deserialize_with.0,
4592 Err(err) => {
4593 return Err(err);
4594 }
4595 }
4596 });
4597 }
4598 Field::HasPos => {
4599 if r#has_pos_property.is_some() {
4600 return Err(<A::Error as de::Error>::duplicate_field("hasPOS"));
4601 }
4602 r#has_pos_property = Some({
4603 struct DeserializeWith(Vec<HasPosProperty>);
4604 impl<'de> Deserialize<'de> for DeserializeWith {
4605 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4606 where
4607 D: Deserializer<'de>,
4608 {
4609 Ok(DeserializeWith(serde_with::As::<
4610 serde_with::OneOrMany<serde_with::Same>,
4611 >::deserialize(deserializer)?))
4612 }
4613 }
4614 match map.next_value::<DeserializeWith>() {
4615 Ok(deserialize_with) => deserialize_with.0,
4616 Err(err) => {
4617 return Err(err);
4618 }
4619 }
4620 });
4621 }
4622 Field::HasProductReturnPolicy => {
4623 if r#has_product_return_policy_property.is_some() {
4624 return Err(<A::Error as de::Error>::duplicate_field(
4625 "hasProductReturnPolicy",
4626 ));
4627 }
4628 r#has_product_return_policy_property = Some({
4629 struct DeserializeWith(Vec<HasProductReturnPolicyProperty>);
4630 impl<'de> Deserialize<'de> for DeserializeWith {
4631 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4632 where
4633 D: Deserializer<'de>,
4634 {
4635 Ok(DeserializeWith(serde_with::As::<
4636 serde_with::OneOrMany<serde_with::Same>,
4637 >::deserialize(deserializer)?))
4638 }
4639 }
4640 match map.next_value::<DeserializeWith>() {
4641 Ok(deserialize_with) => deserialize_with.0,
4642 Err(err) => {
4643 return Err(err);
4644 }
4645 }
4646 });
4647 }
4648 Field::InteractionStatistic => {
4649 if r#interaction_statistic_property.is_some() {
4650 return Err(<A::Error as de::Error>::duplicate_field(
4651 "interactionStatistic",
4652 ));
4653 }
4654 r#interaction_statistic_property = Some({
4655 struct DeserializeWith(Vec<InteractionStatisticProperty>);
4656 impl<'de> Deserialize<'de> for DeserializeWith {
4657 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4658 where
4659 D: Deserializer<'de>,
4660 {
4661 Ok(DeserializeWith(serde_with::As::<
4662 serde_with::OneOrMany<serde_with::Same>,
4663 >::deserialize(deserializer)?))
4664 }
4665 }
4666 match map.next_value::<DeserializeWith>() {
4667 Ok(deserialize_with) => deserialize_with.0,
4668 Err(err) => {
4669 return Err(err);
4670 }
4671 }
4672 });
4673 }
4674 Field::IsicV4 => {
4675 if r#isic_v_4_property.is_some() {
4676 return Err(<A::Error as de::Error>::duplicate_field("isicV4"));
4677 }
4678 r#isic_v_4_property = Some({
4679 struct DeserializeWith(Vec<IsicV4Property>);
4680 impl<'de> Deserialize<'de> for DeserializeWith {
4681 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4682 where
4683 D: Deserializer<'de>,
4684 {
4685 Ok(DeserializeWith(serde_with::As::<
4686 serde_with::OneOrMany<serde_with::Same>,
4687 >::deserialize(deserializer)?))
4688 }
4689 }
4690 match map.next_value::<DeserializeWith>() {
4691 Ok(deserialize_with) => deserialize_with.0,
4692 Err(err) => {
4693 return Err(err);
4694 }
4695 }
4696 });
4697 }
4698 Field::Iso6523Code => {
4699 if r#iso_6523_code_property.is_some() {
4700 return Err(<A::Error as de::Error>::duplicate_field(
4701 "iso6523Code",
4702 ));
4703 }
4704 r#iso_6523_code_property = Some({
4705 struct DeserializeWith(Vec<Iso6523CodeProperty>);
4706 impl<'de> Deserialize<'de> for DeserializeWith {
4707 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4708 where
4709 D: Deserializer<'de>,
4710 {
4711 Ok(DeserializeWith(serde_with::As::<
4712 serde_with::OneOrMany<serde_with::Same>,
4713 >::deserialize(deserializer)?))
4714 }
4715 }
4716 match map.next_value::<DeserializeWith>() {
4717 Ok(deserialize_with) => deserialize_with.0,
4718 Err(err) => {
4719 return Err(err);
4720 }
4721 }
4722 });
4723 }
4724 Field::Keywords => {
4725 if r#keywords_property.is_some() {
4726 return Err(<A::Error as de::Error>::duplicate_field(
4727 "keywords",
4728 ));
4729 }
4730 r#keywords_property = Some({
4731 struct DeserializeWith(Vec<KeywordsProperty>);
4732 impl<'de> Deserialize<'de> for DeserializeWith {
4733 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4734 where
4735 D: Deserializer<'de>,
4736 {
4737 Ok(DeserializeWith(serde_with::As::<
4738 serde_with::OneOrMany<serde_with::Same>,
4739 >::deserialize(deserializer)?))
4740 }
4741 }
4742 match map.next_value::<DeserializeWith>() {
4743 Ok(deserialize_with) => deserialize_with.0,
4744 Err(err) => {
4745 return Err(err);
4746 }
4747 }
4748 });
4749 }
4750 Field::KnowsAbout => {
4751 if r#knows_about_property.is_some() {
4752 return Err(<A::Error as de::Error>::duplicate_field(
4753 "knowsAbout",
4754 ));
4755 }
4756 r#knows_about_property = Some({
4757 struct DeserializeWith(Vec<KnowsAboutProperty>);
4758 impl<'de> Deserialize<'de> for DeserializeWith {
4759 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4760 where
4761 D: Deserializer<'de>,
4762 {
4763 Ok(DeserializeWith(serde_with::As::<
4764 serde_with::OneOrMany<serde_with::Same>,
4765 >::deserialize(deserializer)?))
4766 }
4767 }
4768 match map.next_value::<DeserializeWith>() {
4769 Ok(deserialize_with) => deserialize_with.0,
4770 Err(err) => {
4771 return Err(err);
4772 }
4773 }
4774 });
4775 }
4776 Field::KnowsLanguage => {
4777 if r#knows_language_property.is_some() {
4778 return Err(<A::Error as de::Error>::duplicate_field(
4779 "knowsLanguage",
4780 ));
4781 }
4782 r#knows_language_property = Some({
4783 struct DeserializeWith(Vec<KnowsLanguageProperty>);
4784 impl<'de> Deserialize<'de> for DeserializeWith {
4785 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4786 where
4787 D: Deserializer<'de>,
4788 {
4789 Ok(DeserializeWith(serde_with::As::<
4790 serde_with::OneOrMany<serde_with::Same>,
4791 >::deserialize(deserializer)?))
4792 }
4793 }
4794 match map.next_value::<DeserializeWith>() {
4795 Ok(deserialize_with) => deserialize_with.0,
4796 Err(err) => {
4797 return Err(err);
4798 }
4799 }
4800 });
4801 }
4802 Field::LegalName => {
4803 if r#legal_name_property.is_some() {
4804 return Err(<A::Error as de::Error>::duplicate_field(
4805 "legalName",
4806 ));
4807 }
4808 r#legal_name_property = Some({
4809 struct DeserializeWith(Vec<LegalNameProperty>);
4810 impl<'de> Deserialize<'de> for DeserializeWith {
4811 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4812 where
4813 D: Deserializer<'de>,
4814 {
4815 Ok(DeserializeWith(serde_with::As::<
4816 serde_with::OneOrMany<serde_with::Same>,
4817 >::deserialize(deserializer)?))
4818 }
4819 }
4820 match map.next_value::<DeserializeWith>() {
4821 Ok(deserialize_with) => deserialize_with.0,
4822 Err(err) => {
4823 return Err(err);
4824 }
4825 }
4826 });
4827 }
4828 Field::LeiCode => {
4829 if r#lei_code_property.is_some() {
4830 return Err(<A::Error as de::Error>::duplicate_field(
4831 "leiCode",
4832 ));
4833 }
4834 r#lei_code_property = Some({
4835 struct DeserializeWith(Vec<LeiCodeProperty>);
4836 impl<'de> Deserialize<'de> for DeserializeWith {
4837 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4838 where
4839 D: Deserializer<'de>,
4840 {
4841 Ok(DeserializeWith(serde_with::As::<
4842 serde_with::OneOrMany<serde_with::Same>,
4843 >::deserialize(deserializer)?))
4844 }
4845 }
4846 match map.next_value::<DeserializeWith>() {
4847 Ok(deserialize_with) => deserialize_with.0,
4848 Err(err) => {
4849 return Err(err);
4850 }
4851 }
4852 });
4853 }
4854 Field::Location => {
4855 if r#location_property.is_some() {
4856 return Err(<A::Error as de::Error>::duplicate_field(
4857 "location",
4858 ));
4859 }
4860 r#location_property = Some({
4861 struct DeserializeWith(Vec<LocationProperty>);
4862 impl<'de> Deserialize<'de> for DeserializeWith {
4863 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4864 where
4865 D: Deserializer<'de>,
4866 {
4867 Ok(DeserializeWith(serde_with::As::<
4868 serde_with::OneOrMany<serde_with::Same>,
4869 >::deserialize(deserializer)?))
4870 }
4871 }
4872 match map.next_value::<DeserializeWith>() {
4873 Ok(deserialize_with) => deserialize_with.0,
4874 Err(err) => {
4875 return Err(err);
4876 }
4877 }
4878 });
4879 }
4880 Field::Logo => {
4881 if r#logo_property.is_some() {
4882 return Err(<A::Error as de::Error>::duplicate_field("logo"));
4883 }
4884 r#logo_property = Some({
4885 struct DeserializeWith(Vec<LogoProperty>);
4886 impl<'de> Deserialize<'de> for DeserializeWith {
4887 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4888 where
4889 D: Deserializer<'de>,
4890 {
4891 Ok(DeserializeWith(serde_with::As::<
4892 serde_with::OneOrMany<serde_with::Same>,
4893 >::deserialize(deserializer)?))
4894 }
4895 }
4896 match map.next_value::<DeserializeWith>() {
4897 Ok(deserialize_with) => deserialize_with.0,
4898 Err(err) => {
4899 return Err(err);
4900 }
4901 }
4902 });
4903 }
4904 Field::MakesOffer => {
4905 if r#makes_offer_property.is_some() {
4906 return Err(<A::Error as de::Error>::duplicate_field(
4907 "makesOffer",
4908 ));
4909 }
4910 r#makes_offer_property = Some({
4911 struct DeserializeWith(Vec<MakesOfferProperty>);
4912 impl<'de> Deserialize<'de> for DeserializeWith {
4913 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4914 where
4915 D: Deserializer<'de>,
4916 {
4917 Ok(DeserializeWith(serde_with::As::<
4918 serde_with::OneOrMany<serde_with::Same>,
4919 >::deserialize(deserializer)?))
4920 }
4921 }
4922 match map.next_value::<DeserializeWith>() {
4923 Ok(deserialize_with) => deserialize_with.0,
4924 Err(err) => {
4925 return Err(err);
4926 }
4927 }
4928 });
4929 }
4930 Field::Member => {
4931 if r#member_property.is_some() {
4932 return Err(<A::Error as de::Error>::duplicate_field("member"));
4933 }
4934 r#member_property = Some({
4935 struct DeserializeWith(Vec<MemberProperty>);
4936 impl<'de> Deserialize<'de> for DeserializeWith {
4937 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4938 where
4939 D: Deserializer<'de>,
4940 {
4941 Ok(DeserializeWith(serde_with::As::<
4942 serde_with::OneOrMany<serde_with::Same>,
4943 >::deserialize(deserializer)?))
4944 }
4945 }
4946 match map.next_value::<DeserializeWith>() {
4947 Ok(deserialize_with) => deserialize_with.0,
4948 Err(err) => {
4949 return Err(err);
4950 }
4951 }
4952 });
4953 }
4954 Field::MemberOf => {
4955 if r#member_of_property.is_some() {
4956 return Err(<A::Error as de::Error>::duplicate_field(
4957 "memberOf",
4958 ));
4959 }
4960 r#member_of_property = Some({
4961 struct DeserializeWith(Vec<MemberOfProperty>);
4962 impl<'de> Deserialize<'de> for DeserializeWith {
4963 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4964 where
4965 D: Deserializer<'de>,
4966 {
4967 Ok(DeserializeWith(serde_with::As::<
4968 serde_with::OneOrMany<serde_with::Same>,
4969 >::deserialize(deserializer)?))
4970 }
4971 }
4972 match map.next_value::<DeserializeWith>() {
4973 Ok(deserialize_with) => deserialize_with.0,
4974 Err(err) => {
4975 return Err(err);
4976 }
4977 }
4978 });
4979 }
4980 Field::Members => {
4981 if r#members_property.is_some() {
4982 return Err(<A::Error as de::Error>::duplicate_field(
4983 "members",
4984 ));
4985 }
4986 r#members_property = Some({
4987 struct DeserializeWith(Vec<MembersProperty>);
4988 impl<'de> Deserialize<'de> for DeserializeWith {
4989 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4990 where
4991 D: Deserializer<'de>,
4992 {
4993 Ok(DeserializeWith(serde_with::As::<
4994 serde_with::OneOrMany<serde_with::Same>,
4995 >::deserialize(deserializer)?))
4996 }
4997 }
4998 match map.next_value::<DeserializeWith>() {
4999 Ok(deserialize_with) => deserialize_with.0,
5000 Err(err) => {
5001 return Err(err);
5002 }
5003 }
5004 });
5005 }
5006 Field::Naics => {
5007 if r#naics_property.is_some() {
5008 return Err(<A::Error as de::Error>::duplicate_field("naics"));
5009 }
5010 r#naics_property = Some({
5011 struct DeserializeWith(Vec<NaicsProperty>);
5012 impl<'de> Deserialize<'de> for DeserializeWith {
5013 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5014 where
5015 D: Deserializer<'de>,
5016 {
5017 Ok(DeserializeWith(serde_with::As::<
5018 serde_with::OneOrMany<serde_with::Same>,
5019 >::deserialize(deserializer)?))
5020 }
5021 }
5022 match map.next_value::<DeserializeWith>() {
5023 Ok(deserialize_with) => deserialize_with.0,
5024 Err(err) => {
5025 return Err(err);
5026 }
5027 }
5028 });
5029 }
5030 Field::NonprofitStatus => {
5031 if r#nonprofit_status_property.is_some() {
5032 return Err(<A::Error as de::Error>::duplicate_field(
5033 "nonprofitStatus",
5034 ));
5035 }
5036 r#nonprofit_status_property = Some({
5037 struct DeserializeWith(Vec<NonprofitStatusProperty>);
5038 impl<'de> Deserialize<'de> for DeserializeWith {
5039 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5040 where
5041 D: Deserializer<'de>,
5042 {
5043 Ok(DeserializeWith(serde_with::As::<
5044 serde_with::OneOrMany<serde_with::Same>,
5045 >::deserialize(deserializer)?))
5046 }
5047 }
5048 match map.next_value::<DeserializeWith>() {
5049 Ok(deserialize_with) => deserialize_with.0,
5050 Err(err) => {
5051 return Err(err);
5052 }
5053 }
5054 });
5055 }
5056 Field::NumberOfEmployees => {
5057 if r#number_of_employees_property.is_some() {
5058 return Err(<A::Error as de::Error>::duplicate_field(
5059 "numberOfEmployees",
5060 ));
5061 }
5062 r#number_of_employees_property = Some({
5063 struct DeserializeWith(Vec<NumberOfEmployeesProperty>);
5064 impl<'de> Deserialize<'de> for DeserializeWith {
5065 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5066 where
5067 D: Deserializer<'de>,
5068 {
5069 Ok(DeserializeWith(serde_with::As::<
5070 serde_with::OneOrMany<serde_with::Same>,
5071 >::deserialize(deserializer)?))
5072 }
5073 }
5074 match map.next_value::<DeserializeWith>() {
5075 Ok(deserialize_with) => deserialize_with.0,
5076 Err(err) => {
5077 return Err(err);
5078 }
5079 }
5080 });
5081 }
5082 Field::OwnershipFundingInfo => {
5083 if r#ownership_funding_info_property.is_some() {
5084 return Err(<A::Error as de::Error>::duplicate_field(
5085 "ownershipFundingInfo",
5086 ));
5087 }
5088 r#ownership_funding_info_property = Some({
5089 struct DeserializeWith(Vec<OwnershipFundingInfoProperty>);
5090 impl<'de> Deserialize<'de> for DeserializeWith {
5091 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5092 where
5093 D: Deserializer<'de>,
5094 {
5095 Ok(DeserializeWith(serde_with::As::<
5096 serde_with::OneOrMany<serde_with::Same>,
5097 >::deserialize(deserializer)?))
5098 }
5099 }
5100 match map.next_value::<DeserializeWith>() {
5101 Ok(deserialize_with) => deserialize_with.0,
5102 Err(err) => {
5103 return Err(err);
5104 }
5105 }
5106 });
5107 }
5108 Field::Owns => {
5109 if r#owns_property.is_some() {
5110 return Err(<A::Error as de::Error>::duplicate_field("owns"));
5111 }
5112 r#owns_property = Some({
5113 struct DeserializeWith(Vec<OwnsProperty>);
5114 impl<'de> Deserialize<'de> for DeserializeWith {
5115 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5116 where
5117 D: Deserializer<'de>,
5118 {
5119 Ok(DeserializeWith(serde_with::As::<
5120 serde_with::OneOrMany<serde_with::Same>,
5121 >::deserialize(deserializer)?))
5122 }
5123 }
5124 match map.next_value::<DeserializeWith>() {
5125 Ok(deserialize_with) => deserialize_with.0,
5126 Err(err) => {
5127 return Err(err);
5128 }
5129 }
5130 });
5131 }
5132 Field::ParentOrganization => {
5133 if r#parent_organization_property.is_some() {
5134 return Err(<A::Error as de::Error>::duplicate_field(
5135 "parentOrganization",
5136 ));
5137 }
5138 r#parent_organization_property = Some({
5139 struct DeserializeWith(Vec<ParentOrganizationProperty>);
5140 impl<'de> Deserialize<'de> for DeserializeWith {
5141 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5142 where
5143 D: Deserializer<'de>,
5144 {
5145 Ok(DeserializeWith(serde_with::As::<
5146 serde_with::OneOrMany<serde_with::Same>,
5147 >::deserialize(deserializer)?))
5148 }
5149 }
5150 match map.next_value::<DeserializeWith>() {
5151 Ok(deserialize_with) => deserialize_with.0,
5152 Err(err) => {
5153 return Err(err);
5154 }
5155 }
5156 });
5157 }
5158 Field::PublishingPrinciples => {
5159 if r#publishing_principles_property.is_some() {
5160 return Err(<A::Error as de::Error>::duplicate_field(
5161 "publishingPrinciples",
5162 ));
5163 }
5164 r#publishing_principles_property = Some({
5165 struct DeserializeWith(Vec<PublishingPrinciplesProperty>);
5166 impl<'de> Deserialize<'de> for DeserializeWith {
5167 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5168 where
5169 D: Deserializer<'de>,
5170 {
5171 Ok(DeserializeWith(serde_with::As::<
5172 serde_with::OneOrMany<serde_with::Same>,
5173 >::deserialize(deserializer)?))
5174 }
5175 }
5176 match map.next_value::<DeserializeWith>() {
5177 Ok(deserialize_with) => deserialize_with.0,
5178 Err(err) => {
5179 return Err(err);
5180 }
5181 }
5182 });
5183 }
5184 Field::Review => {
5185 if r#review_property.is_some() {
5186 return Err(<A::Error as de::Error>::duplicate_field("review"));
5187 }
5188 r#review_property = Some({
5189 struct DeserializeWith(Vec<ReviewProperty>);
5190 impl<'de> Deserialize<'de> for DeserializeWith {
5191 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5192 where
5193 D: Deserializer<'de>,
5194 {
5195 Ok(DeserializeWith(serde_with::As::<
5196 serde_with::OneOrMany<serde_with::Same>,
5197 >::deserialize(deserializer)?))
5198 }
5199 }
5200 match map.next_value::<DeserializeWith>() {
5201 Ok(deserialize_with) => deserialize_with.0,
5202 Err(err) => {
5203 return Err(err);
5204 }
5205 }
5206 });
5207 }
5208 Field::Reviews => {
5209 if r#reviews_property.is_some() {
5210 return Err(<A::Error as de::Error>::duplicate_field(
5211 "reviews",
5212 ));
5213 }
5214 r#reviews_property = Some({
5215 struct DeserializeWith(Vec<ReviewsProperty>);
5216 impl<'de> Deserialize<'de> for DeserializeWith {
5217 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5218 where
5219 D: Deserializer<'de>,
5220 {
5221 Ok(DeserializeWith(serde_with::As::<
5222 serde_with::OneOrMany<serde_with::Same>,
5223 >::deserialize(deserializer)?))
5224 }
5225 }
5226 match map.next_value::<DeserializeWith>() {
5227 Ok(deserialize_with) => deserialize_with.0,
5228 Err(err) => {
5229 return Err(err);
5230 }
5231 }
5232 });
5233 }
5234 Field::Seeks => {
5235 if r#seeks_property.is_some() {
5236 return Err(<A::Error as de::Error>::duplicate_field("seeks"));
5237 }
5238 r#seeks_property = Some({
5239 struct DeserializeWith(Vec<SeeksProperty>);
5240 impl<'de> Deserialize<'de> for DeserializeWith {
5241 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5242 where
5243 D: Deserializer<'de>,
5244 {
5245 Ok(DeserializeWith(serde_with::As::<
5246 serde_with::OneOrMany<serde_with::Same>,
5247 >::deserialize(deserializer)?))
5248 }
5249 }
5250 match map.next_value::<DeserializeWith>() {
5251 Ok(deserialize_with) => deserialize_with.0,
5252 Err(err) => {
5253 return Err(err);
5254 }
5255 }
5256 });
5257 }
5258 Field::ServiceArea => {
5259 if r#service_area_property.is_some() {
5260 return Err(<A::Error as de::Error>::duplicate_field(
5261 "serviceArea",
5262 ));
5263 }
5264 r#service_area_property = Some({
5265 struct DeserializeWith(Vec<ServiceAreaProperty>);
5266 impl<'de> Deserialize<'de> for DeserializeWith {
5267 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5268 where
5269 D: Deserializer<'de>,
5270 {
5271 Ok(DeserializeWith(serde_with::As::<
5272 serde_with::OneOrMany<serde_with::Same>,
5273 >::deserialize(deserializer)?))
5274 }
5275 }
5276 match map.next_value::<DeserializeWith>() {
5277 Ok(deserialize_with) => deserialize_with.0,
5278 Err(err) => {
5279 return Err(err);
5280 }
5281 }
5282 });
5283 }
5284 Field::Slogan => {
5285 if r#slogan_property.is_some() {
5286 return Err(<A::Error as de::Error>::duplicate_field("slogan"));
5287 }
5288 r#slogan_property = Some({
5289 struct DeserializeWith(Vec<SloganProperty>);
5290 impl<'de> Deserialize<'de> for DeserializeWith {
5291 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5292 where
5293 D: Deserializer<'de>,
5294 {
5295 Ok(DeserializeWith(serde_with::As::<
5296 serde_with::OneOrMany<serde_with::Same>,
5297 >::deserialize(deserializer)?))
5298 }
5299 }
5300 match map.next_value::<DeserializeWith>() {
5301 Ok(deserialize_with) => deserialize_with.0,
5302 Err(err) => {
5303 return Err(err);
5304 }
5305 }
5306 });
5307 }
5308 Field::Sponsor => {
5309 if r#sponsor_property.is_some() {
5310 return Err(<A::Error as de::Error>::duplicate_field(
5311 "sponsor",
5312 ));
5313 }
5314 r#sponsor_property = Some({
5315 struct DeserializeWith(Vec<SponsorProperty>);
5316 impl<'de> Deserialize<'de> for DeserializeWith {
5317 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5318 where
5319 D: Deserializer<'de>,
5320 {
5321 Ok(DeserializeWith(serde_with::As::<
5322 serde_with::OneOrMany<serde_with::Same>,
5323 >::deserialize(deserializer)?))
5324 }
5325 }
5326 match map.next_value::<DeserializeWith>() {
5327 Ok(deserialize_with) => deserialize_with.0,
5328 Err(err) => {
5329 return Err(err);
5330 }
5331 }
5332 });
5333 }
5334 Field::SubOrganization => {
5335 if r#sub_organization_property.is_some() {
5336 return Err(<A::Error as de::Error>::duplicate_field(
5337 "subOrganization",
5338 ));
5339 }
5340 r#sub_organization_property = Some({
5341 struct DeserializeWith(Vec<SubOrganizationProperty>);
5342 impl<'de> Deserialize<'de> for DeserializeWith {
5343 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5344 where
5345 D: Deserializer<'de>,
5346 {
5347 Ok(DeserializeWith(serde_with::As::<
5348 serde_with::OneOrMany<serde_with::Same>,
5349 >::deserialize(deserializer)?))
5350 }
5351 }
5352 match map.next_value::<DeserializeWith>() {
5353 Ok(deserialize_with) => deserialize_with.0,
5354 Err(err) => {
5355 return Err(err);
5356 }
5357 }
5358 });
5359 }
5360 Field::TaxId => {
5361 if r#tax_id_property.is_some() {
5362 return Err(<A::Error as de::Error>::duplicate_field("taxID"));
5363 }
5364 r#tax_id_property = Some({
5365 struct DeserializeWith(Vec<TaxIdProperty>);
5366 impl<'de> Deserialize<'de> for DeserializeWith {
5367 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5368 where
5369 D: Deserializer<'de>,
5370 {
5371 Ok(DeserializeWith(serde_with::As::<
5372 serde_with::OneOrMany<serde_with::Same>,
5373 >::deserialize(deserializer)?))
5374 }
5375 }
5376 match map.next_value::<DeserializeWith>() {
5377 Ok(deserialize_with) => deserialize_with.0,
5378 Err(err) => {
5379 return Err(err);
5380 }
5381 }
5382 });
5383 }
5384 Field::Telephone => {
5385 if r#telephone_property.is_some() {
5386 return Err(<A::Error as de::Error>::duplicate_field(
5387 "telephone",
5388 ));
5389 }
5390 r#telephone_property = Some({
5391 struct DeserializeWith(Vec<TelephoneProperty>);
5392 impl<'de> Deserialize<'de> for DeserializeWith {
5393 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5394 where
5395 D: Deserializer<'de>,
5396 {
5397 Ok(DeserializeWith(serde_with::As::<
5398 serde_with::OneOrMany<serde_with::Same>,
5399 >::deserialize(deserializer)?))
5400 }
5401 }
5402 match map.next_value::<DeserializeWith>() {
5403 Ok(deserialize_with) => deserialize_with.0,
5404 Err(err) => {
5405 return Err(err);
5406 }
5407 }
5408 });
5409 }
5410 Field::UnnamedSourcesPolicy => {
5411 if r#unnamed_sources_policy_property.is_some() {
5412 return Err(<A::Error as de::Error>::duplicate_field(
5413 "unnamedSourcesPolicy",
5414 ));
5415 }
5416 r#unnamed_sources_policy_property = Some({
5417 struct DeserializeWith(Vec<UnnamedSourcesPolicyProperty>);
5418 impl<'de> Deserialize<'de> for DeserializeWith {
5419 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5420 where
5421 D: Deserializer<'de>,
5422 {
5423 Ok(DeserializeWith(serde_with::As::<
5424 serde_with::OneOrMany<serde_with::Same>,
5425 >::deserialize(deserializer)?))
5426 }
5427 }
5428 match map.next_value::<DeserializeWith>() {
5429 Ok(deserialize_with) => deserialize_with.0,
5430 Err(err) => {
5431 return Err(err);
5432 }
5433 }
5434 });
5435 }
5436 Field::VatId => {
5437 if r#vat_id_property.is_some() {
5438 return Err(<A::Error as de::Error>::duplicate_field("vatID"));
5439 }
5440 r#vat_id_property = Some({
5441 struct DeserializeWith(Vec<VatIdProperty>);
5442 impl<'de> Deserialize<'de> for DeserializeWith {
5443 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5444 where
5445 D: Deserializer<'de>,
5446 {
5447 Ok(DeserializeWith(serde_with::As::<
5448 serde_with::OneOrMany<serde_with::Same>,
5449 >::deserialize(deserializer)?))
5450 }
5451 }
5452 match map.next_value::<DeserializeWith>() {
5453 Ok(deserialize_with) => deserialize_with.0,
5454 Err(err) => {
5455 return Err(err);
5456 }
5457 }
5458 });
5459 }
5460 Field::AdditionalProperty => {
5461 if r#additional_property_property.is_some() {
5462 return Err(<A::Error as de::Error>::duplicate_field(
5463 "additionalProperty",
5464 ));
5465 }
5466 r#additional_property_property = Some({
5467 struct DeserializeWith(Vec<AdditionalPropertyProperty>);
5468 impl<'de> Deserialize<'de> for DeserializeWith {
5469 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5470 where
5471 D: Deserializer<'de>,
5472 {
5473 Ok(DeserializeWith(serde_with::As::<
5474 serde_with::OneOrMany<serde_with::Same>,
5475 >::deserialize(deserializer)?))
5476 }
5477 }
5478 match map.next_value::<DeserializeWith>() {
5479 Ok(deserialize_with) => deserialize_with.0,
5480 Err(err) => {
5481 return Err(err);
5482 }
5483 }
5484 });
5485 }
5486 Field::AmenityFeature => {
5487 if r#amenity_feature_property.is_some() {
5488 return Err(<A::Error as de::Error>::duplicate_field(
5489 "amenityFeature",
5490 ));
5491 }
5492 r#amenity_feature_property = Some({
5493 struct DeserializeWith(Vec<AmenityFeatureProperty>);
5494 impl<'de> Deserialize<'de> for DeserializeWith {
5495 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5496 where
5497 D: Deserializer<'de>,
5498 {
5499 Ok(DeserializeWith(serde_with::As::<
5500 serde_with::OneOrMany<serde_with::Same>,
5501 >::deserialize(deserializer)?))
5502 }
5503 }
5504 match map.next_value::<DeserializeWith>() {
5505 Ok(deserialize_with) => deserialize_with.0,
5506 Err(err) => {
5507 return Err(err);
5508 }
5509 }
5510 });
5511 }
5512 Field::BranchCode => {
5513 if r#branch_code_property.is_some() {
5514 return Err(<A::Error as de::Error>::duplicate_field(
5515 "branchCode",
5516 ));
5517 }
5518 r#branch_code_property = Some({
5519 struct DeserializeWith(Vec<BranchCodeProperty>);
5520 impl<'de> Deserialize<'de> for DeserializeWith {
5521 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5522 where
5523 D: Deserializer<'de>,
5524 {
5525 Ok(DeserializeWith(serde_with::As::<
5526 serde_with::OneOrMany<serde_with::Same>,
5527 >::deserialize(deserializer)?))
5528 }
5529 }
5530 match map.next_value::<DeserializeWith>() {
5531 Ok(deserialize_with) => deserialize_with.0,
5532 Err(err) => {
5533 return Err(err);
5534 }
5535 }
5536 });
5537 }
5538 Field::ContainedIn => {
5539 if r#contained_in_property.is_some() {
5540 return Err(<A::Error as de::Error>::duplicate_field(
5541 "containedIn",
5542 ));
5543 }
5544 r#contained_in_property = Some({
5545 struct DeserializeWith(Vec<ContainedInProperty>);
5546 impl<'de> Deserialize<'de> for DeserializeWith {
5547 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5548 where
5549 D: Deserializer<'de>,
5550 {
5551 Ok(DeserializeWith(serde_with::As::<
5552 serde_with::OneOrMany<serde_with::Same>,
5553 >::deserialize(deserializer)?))
5554 }
5555 }
5556 match map.next_value::<DeserializeWith>() {
5557 Ok(deserialize_with) => deserialize_with.0,
5558 Err(err) => {
5559 return Err(err);
5560 }
5561 }
5562 });
5563 }
5564 Field::ContainedInPlace => {
5565 if r#contained_in_place_property.is_some() {
5566 return Err(<A::Error as de::Error>::duplicate_field(
5567 "containedInPlace",
5568 ));
5569 }
5570 r#contained_in_place_property = Some({
5571 struct DeserializeWith(Vec<ContainedInPlaceProperty>);
5572 impl<'de> Deserialize<'de> for DeserializeWith {
5573 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5574 where
5575 D: Deserializer<'de>,
5576 {
5577 Ok(DeserializeWith(serde_with::As::<
5578 serde_with::OneOrMany<serde_with::Same>,
5579 >::deserialize(deserializer)?))
5580 }
5581 }
5582 match map.next_value::<DeserializeWith>() {
5583 Ok(deserialize_with) => deserialize_with.0,
5584 Err(err) => {
5585 return Err(err);
5586 }
5587 }
5588 });
5589 }
5590 Field::ContainsPlace => {
5591 if r#contains_place_property.is_some() {
5592 return Err(<A::Error as de::Error>::duplicate_field(
5593 "containsPlace",
5594 ));
5595 }
5596 r#contains_place_property = Some({
5597 struct DeserializeWith(Vec<ContainsPlaceProperty>);
5598 impl<'de> Deserialize<'de> for DeserializeWith {
5599 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5600 where
5601 D: Deserializer<'de>,
5602 {
5603 Ok(DeserializeWith(serde_with::As::<
5604 serde_with::OneOrMany<serde_with::Same>,
5605 >::deserialize(deserializer)?))
5606 }
5607 }
5608 match map.next_value::<DeserializeWith>() {
5609 Ok(deserialize_with) => deserialize_with.0,
5610 Err(err) => {
5611 return Err(err);
5612 }
5613 }
5614 });
5615 }
5616 Field::Geo => {
5617 if r#geo_property.is_some() {
5618 return Err(<A::Error as de::Error>::duplicate_field("geo"));
5619 }
5620 r#geo_property = Some({
5621 struct DeserializeWith(Vec<GeoProperty>);
5622 impl<'de> Deserialize<'de> for DeserializeWith {
5623 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5624 where
5625 D: Deserializer<'de>,
5626 {
5627 Ok(DeserializeWith(serde_with::As::<
5628 serde_with::OneOrMany<serde_with::Same>,
5629 >::deserialize(deserializer)?))
5630 }
5631 }
5632 match map.next_value::<DeserializeWith>() {
5633 Ok(deserialize_with) => deserialize_with.0,
5634 Err(err) => {
5635 return Err(err);
5636 }
5637 }
5638 });
5639 }
5640 Field::GeoContains => {
5641 if r#geo_contains_property.is_some() {
5642 return Err(<A::Error as de::Error>::duplicate_field(
5643 "geoContains",
5644 ));
5645 }
5646 r#geo_contains_property = Some({
5647 struct DeserializeWith(Vec<GeoContainsProperty>);
5648 impl<'de> Deserialize<'de> for DeserializeWith {
5649 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5650 where
5651 D: Deserializer<'de>,
5652 {
5653 Ok(DeserializeWith(serde_with::As::<
5654 serde_with::OneOrMany<serde_with::Same>,
5655 >::deserialize(deserializer)?))
5656 }
5657 }
5658 match map.next_value::<DeserializeWith>() {
5659 Ok(deserialize_with) => deserialize_with.0,
5660 Err(err) => {
5661 return Err(err);
5662 }
5663 }
5664 });
5665 }
5666 Field::GeoCoveredBy => {
5667 if r#geo_covered_by_property.is_some() {
5668 return Err(<A::Error as de::Error>::duplicate_field(
5669 "geoCoveredBy",
5670 ));
5671 }
5672 r#geo_covered_by_property = Some({
5673 struct DeserializeWith(Vec<GeoCoveredByProperty>);
5674 impl<'de> Deserialize<'de> for DeserializeWith {
5675 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5676 where
5677 D: Deserializer<'de>,
5678 {
5679 Ok(DeserializeWith(serde_with::As::<
5680 serde_with::OneOrMany<serde_with::Same>,
5681 >::deserialize(deserializer)?))
5682 }
5683 }
5684 match map.next_value::<DeserializeWith>() {
5685 Ok(deserialize_with) => deserialize_with.0,
5686 Err(err) => {
5687 return Err(err);
5688 }
5689 }
5690 });
5691 }
5692 Field::GeoCovers => {
5693 if r#geo_covers_property.is_some() {
5694 return Err(<A::Error as de::Error>::duplicate_field(
5695 "geoCovers",
5696 ));
5697 }
5698 r#geo_covers_property = Some({
5699 struct DeserializeWith(Vec<GeoCoversProperty>);
5700 impl<'de> Deserialize<'de> for DeserializeWith {
5701 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5702 where
5703 D: Deserializer<'de>,
5704 {
5705 Ok(DeserializeWith(serde_with::As::<
5706 serde_with::OneOrMany<serde_with::Same>,
5707 >::deserialize(deserializer)?))
5708 }
5709 }
5710 match map.next_value::<DeserializeWith>() {
5711 Ok(deserialize_with) => deserialize_with.0,
5712 Err(err) => {
5713 return Err(err);
5714 }
5715 }
5716 });
5717 }
5718 Field::GeoCrosses => {
5719 if r#geo_crosses_property.is_some() {
5720 return Err(<A::Error as de::Error>::duplicate_field(
5721 "geoCrosses",
5722 ));
5723 }
5724 r#geo_crosses_property = Some({
5725 struct DeserializeWith(Vec<GeoCrossesProperty>);
5726 impl<'de> Deserialize<'de> for DeserializeWith {
5727 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5728 where
5729 D: Deserializer<'de>,
5730 {
5731 Ok(DeserializeWith(serde_with::As::<
5732 serde_with::OneOrMany<serde_with::Same>,
5733 >::deserialize(deserializer)?))
5734 }
5735 }
5736 match map.next_value::<DeserializeWith>() {
5737 Ok(deserialize_with) => deserialize_with.0,
5738 Err(err) => {
5739 return Err(err);
5740 }
5741 }
5742 });
5743 }
5744 Field::GeoDisjoint => {
5745 if r#geo_disjoint_property.is_some() {
5746 return Err(<A::Error as de::Error>::duplicate_field(
5747 "geoDisjoint",
5748 ));
5749 }
5750 r#geo_disjoint_property = Some({
5751 struct DeserializeWith(Vec<GeoDisjointProperty>);
5752 impl<'de> Deserialize<'de> for DeserializeWith {
5753 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5754 where
5755 D: Deserializer<'de>,
5756 {
5757 Ok(DeserializeWith(serde_with::As::<
5758 serde_with::OneOrMany<serde_with::Same>,
5759 >::deserialize(deserializer)?))
5760 }
5761 }
5762 match map.next_value::<DeserializeWith>() {
5763 Ok(deserialize_with) => deserialize_with.0,
5764 Err(err) => {
5765 return Err(err);
5766 }
5767 }
5768 });
5769 }
5770 Field::GeoEquals => {
5771 if r#geo_equals_property.is_some() {
5772 return Err(<A::Error as de::Error>::duplicate_field(
5773 "geoEquals",
5774 ));
5775 }
5776 r#geo_equals_property = Some({
5777 struct DeserializeWith(Vec<GeoEqualsProperty>);
5778 impl<'de> Deserialize<'de> for DeserializeWith {
5779 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5780 where
5781 D: Deserializer<'de>,
5782 {
5783 Ok(DeserializeWith(serde_with::As::<
5784 serde_with::OneOrMany<serde_with::Same>,
5785 >::deserialize(deserializer)?))
5786 }
5787 }
5788 match map.next_value::<DeserializeWith>() {
5789 Ok(deserialize_with) => deserialize_with.0,
5790 Err(err) => {
5791 return Err(err);
5792 }
5793 }
5794 });
5795 }
5796 Field::GeoIntersects => {
5797 if r#geo_intersects_property.is_some() {
5798 return Err(<A::Error as de::Error>::duplicate_field(
5799 "geoIntersects",
5800 ));
5801 }
5802 r#geo_intersects_property = Some({
5803 struct DeserializeWith(Vec<GeoIntersectsProperty>);
5804 impl<'de> Deserialize<'de> for DeserializeWith {
5805 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5806 where
5807 D: Deserializer<'de>,
5808 {
5809 Ok(DeserializeWith(serde_with::As::<
5810 serde_with::OneOrMany<serde_with::Same>,
5811 >::deserialize(deserializer)?))
5812 }
5813 }
5814 match map.next_value::<DeserializeWith>() {
5815 Ok(deserialize_with) => deserialize_with.0,
5816 Err(err) => {
5817 return Err(err);
5818 }
5819 }
5820 });
5821 }
5822 Field::GeoOverlaps => {
5823 if r#geo_overlaps_property.is_some() {
5824 return Err(<A::Error as de::Error>::duplicate_field(
5825 "geoOverlaps",
5826 ));
5827 }
5828 r#geo_overlaps_property = Some({
5829 struct DeserializeWith(Vec<GeoOverlapsProperty>);
5830 impl<'de> Deserialize<'de> for DeserializeWith {
5831 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5832 where
5833 D: Deserializer<'de>,
5834 {
5835 Ok(DeserializeWith(serde_with::As::<
5836 serde_with::OneOrMany<serde_with::Same>,
5837 >::deserialize(deserializer)?))
5838 }
5839 }
5840 match map.next_value::<DeserializeWith>() {
5841 Ok(deserialize_with) => deserialize_with.0,
5842 Err(err) => {
5843 return Err(err);
5844 }
5845 }
5846 });
5847 }
5848 Field::GeoTouches => {
5849 if r#geo_touches_property.is_some() {
5850 return Err(<A::Error as de::Error>::duplicate_field(
5851 "geoTouches",
5852 ));
5853 }
5854 r#geo_touches_property = Some({
5855 struct DeserializeWith(Vec<GeoTouchesProperty>);
5856 impl<'de> Deserialize<'de> for DeserializeWith {
5857 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5858 where
5859 D: Deserializer<'de>,
5860 {
5861 Ok(DeserializeWith(serde_with::As::<
5862 serde_with::OneOrMany<serde_with::Same>,
5863 >::deserialize(deserializer)?))
5864 }
5865 }
5866 match map.next_value::<DeserializeWith>() {
5867 Ok(deserialize_with) => deserialize_with.0,
5868 Err(err) => {
5869 return Err(err);
5870 }
5871 }
5872 });
5873 }
5874 Field::GeoWithin => {
5875 if r#geo_within_property.is_some() {
5876 return Err(<A::Error as de::Error>::duplicate_field(
5877 "geoWithin",
5878 ));
5879 }
5880 r#geo_within_property = Some({
5881 struct DeserializeWith(Vec<GeoWithinProperty>);
5882 impl<'de> Deserialize<'de> for DeserializeWith {
5883 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5884 where
5885 D: Deserializer<'de>,
5886 {
5887 Ok(DeserializeWith(serde_with::As::<
5888 serde_with::OneOrMany<serde_with::Same>,
5889 >::deserialize(deserializer)?))
5890 }
5891 }
5892 match map.next_value::<DeserializeWith>() {
5893 Ok(deserialize_with) => deserialize_with.0,
5894 Err(err) => {
5895 return Err(err);
5896 }
5897 }
5898 });
5899 }
5900 Field::HasDriveThroughService => {
5901 if r#has_drive_through_service_property.is_some() {
5902 return Err(<A::Error as de::Error>::duplicate_field(
5903 "hasDriveThroughService",
5904 ));
5905 }
5906 r#has_drive_through_service_property = Some({
5907 struct DeserializeWith(Vec<HasDriveThroughServiceProperty>);
5908 impl<'de> Deserialize<'de> for DeserializeWith {
5909 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5910 where
5911 D: Deserializer<'de>,
5912 {
5913 Ok(DeserializeWith(serde_with::As::<
5914 serde_with::OneOrMany<serde_with::Same>,
5915 >::deserialize(deserializer)?))
5916 }
5917 }
5918 match map.next_value::<DeserializeWith>() {
5919 Ok(deserialize_with) => deserialize_with.0,
5920 Err(err) => {
5921 return Err(err);
5922 }
5923 }
5924 });
5925 }
5926 Field::HasMap => {
5927 if r#has_map_property.is_some() {
5928 return Err(<A::Error as de::Error>::duplicate_field("hasMap"));
5929 }
5930 r#has_map_property = Some({
5931 struct DeserializeWith(Vec<HasMapProperty>);
5932 impl<'de> Deserialize<'de> for DeserializeWith {
5933 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5934 where
5935 D: Deserializer<'de>,
5936 {
5937 Ok(DeserializeWith(serde_with::As::<
5938 serde_with::OneOrMany<serde_with::Same>,
5939 >::deserialize(deserializer)?))
5940 }
5941 }
5942 match map.next_value::<DeserializeWith>() {
5943 Ok(deserialize_with) => deserialize_with.0,
5944 Err(err) => {
5945 return Err(err);
5946 }
5947 }
5948 });
5949 }
5950 Field::IsAccessibleForFree => {
5951 if r#is_accessible_for_free_property.is_some() {
5952 return Err(<A::Error as de::Error>::duplicate_field(
5953 "isAccessibleForFree",
5954 ));
5955 }
5956 r#is_accessible_for_free_property = Some({
5957 struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
5958 impl<'de> Deserialize<'de> for DeserializeWith {
5959 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5960 where
5961 D: Deserializer<'de>,
5962 {
5963 Ok(DeserializeWith(serde_with::As::<
5964 serde_with::OneOrMany<serde_with::Same>,
5965 >::deserialize(deserializer)?))
5966 }
5967 }
5968 match map.next_value::<DeserializeWith>() {
5969 Ok(deserialize_with) => deserialize_with.0,
5970 Err(err) => {
5971 return Err(err);
5972 }
5973 }
5974 });
5975 }
5976 Field::Latitude => {
5977 if r#latitude_property.is_some() {
5978 return Err(<A::Error as de::Error>::duplicate_field(
5979 "latitude",
5980 ));
5981 }
5982 r#latitude_property = Some({
5983 struct DeserializeWith(Vec<LatitudeProperty>);
5984 impl<'de> Deserialize<'de> for DeserializeWith {
5985 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5986 where
5987 D: Deserializer<'de>,
5988 {
5989 Ok(DeserializeWith(serde_with::As::<
5990 serde_with::OneOrMany<serde_with::Same>,
5991 >::deserialize(deserializer)?))
5992 }
5993 }
5994 match map.next_value::<DeserializeWith>() {
5995 Ok(deserialize_with) => deserialize_with.0,
5996 Err(err) => {
5997 return Err(err);
5998 }
5999 }
6000 });
6001 }
6002 Field::Longitude => {
6003 if r#longitude_property.is_some() {
6004 return Err(<A::Error as de::Error>::duplicate_field(
6005 "longitude",
6006 ));
6007 }
6008 r#longitude_property = Some({
6009 struct DeserializeWith(Vec<LongitudeProperty>);
6010 impl<'de> Deserialize<'de> for DeserializeWith {
6011 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6012 where
6013 D: Deserializer<'de>,
6014 {
6015 Ok(DeserializeWith(serde_with::As::<
6016 serde_with::OneOrMany<serde_with::Same>,
6017 >::deserialize(deserializer)?))
6018 }
6019 }
6020 match map.next_value::<DeserializeWith>() {
6021 Ok(deserialize_with) => deserialize_with.0,
6022 Err(err) => {
6023 return Err(err);
6024 }
6025 }
6026 });
6027 }
6028 Field::Map => {
6029 if r#map_property.is_some() {
6030 return Err(<A::Error as de::Error>::duplicate_field("map"));
6031 }
6032 r#map_property = Some({
6033 struct DeserializeWith(Vec<MapProperty>);
6034 impl<'de> Deserialize<'de> for DeserializeWith {
6035 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6036 where
6037 D: Deserializer<'de>,
6038 {
6039 Ok(DeserializeWith(serde_with::As::<
6040 serde_with::OneOrMany<serde_with::Same>,
6041 >::deserialize(deserializer)?))
6042 }
6043 }
6044 match map.next_value::<DeserializeWith>() {
6045 Ok(deserialize_with) => deserialize_with.0,
6046 Err(err) => {
6047 return Err(err);
6048 }
6049 }
6050 });
6051 }
6052 Field::Maps => {
6053 if r#maps_property.is_some() {
6054 return Err(<A::Error as de::Error>::duplicate_field("maps"));
6055 }
6056 r#maps_property = Some({
6057 struct DeserializeWith(Vec<MapsProperty>);
6058 impl<'de> Deserialize<'de> for DeserializeWith {
6059 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6060 where
6061 D: Deserializer<'de>,
6062 {
6063 Ok(DeserializeWith(serde_with::As::<
6064 serde_with::OneOrMany<serde_with::Same>,
6065 >::deserialize(deserializer)?))
6066 }
6067 }
6068 match map.next_value::<DeserializeWith>() {
6069 Ok(deserialize_with) => deserialize_with.0,
6070 Err(err) => {
6071 return Err(err);
6072 }
6073 }
6074 });
6075 }
6076 Field::MaximumAttendeeCapacity => {
6077 if r#maximum_attendee_capacity_property.is_some() {
6078 return Err(<A::Error as de::Error>::duplicate_field(
6079 "maximumAttendeeCapacity",
6080 ));
6081 }
6082 r#maximum_attendee_capacity_property = Some({
6083 struct DeserializeWith(Vec<MaximumAttendeeCapacityProperty>);
6084 impl<'de> Deserialize<'de> for DeserializeWith {
6085 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6086 where
6087 D: Deserializer<'de>,
6088 {
6089 Ok(DeserializeWith(serde_with::As::<
6090 serde_with::OneOrMany<serde_with::Same>,
6091 >::deserialize(deserializer)?))
6092 }
6093 }
6094 match map.next_value::<DeserializeWith>() {
6095 Ok(deserialize_with) => deserialize_with.0,
6096 Err(err) => {
6097 return Err(err);
6098 }
6099 }
6100 });
6101 }
6102 Field::OpeningHoursSpecification => {
6103 if r#opening_hours_specification_property.is_some() {
6104 return Err(<A::Error as de::Error>::duplicate_field(
6105 "openingHoursSpecification",
6106 ));
6107 }
6108 r#opening_hours_specification_property = Some({
6109 struct DeserializeWith(Vec<OpeningHoursSpecificationProperty>);
6110 impl<'de> Deserialize<'de> for DeserializeWith {
6111 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6112 where
6113 D: Deserializer<'de>,
6114 {
6115 Ok(DeserializeWith(serde_with::As::<
6116 serde_with::OneOrMany<serde_with::Same>,
6117 >::deserialize(deserializer)?))
6118 }
6119 }
6120 match map.next_value::<DeserializeWith>() {
6121 Ok(deserialize_with) => deserialize_with.0,
6122 Err(err) => {
6123 return Err(err);
6124 }
6125 }
6126 });
6127 }
6128 Field::Photo => {
6129 if r#photo_property.is_some() {
6130 return Err(<A::Error as de::Error>::duplicate_field("photo"));
6131 }
6132 r#photo_property = Some({
6133 struct DeserializeWith(Vec<PhotoProperty>);
6134 impl<'de> Deserialize<'de> for DeserializeWith {
6135 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6136 where
6137 D: Deserializer<'de>,
6138 {
6139 Ok(DeserializeWith(serde_with::As::<
6140 serde_with::OneOrMany<serde_with::Same>,
6141 >::deserialize(deserializer)?))
6142 }
6143 }
6144 match map.next_value::<DeserializeWith>() {
6145 Ok(deserialize_with) => deserialize_with.0,
6146 Err(err) => {
6147 return Err(err);
6148 }
6149 }
6150 });
6151 }
6152 Field::Photos => {
6153 if r#photos_property.is_some() {
6154 return Err(<A::Error as de::Error>::duplicate_field("photos"));
6155 }
6156 r#photos_property = Some({
6157 struct DeserializeWith(Vec<PhotosProperty>);
6158 impl<'de> Deserialize<'de> for DeserializeWith {
6159 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6160 where
6161 D: Deserializer<'de>,
6162 {
6163 Ok(DeserializeWith(serde_with::As::<
6164 serde_with::OneOrMany<serde_with::Same>,
6165 >::deserialize(deserializer)?))
6166 }
6167 }
6168 match map.next_value::<DeserializeWith>() {
6169 Ok(deserialize_with) => deserialize_with.0,
6170 Err(err) => {
6171 return Err(err);
6172 }
6173 }
6174 });
6175 }
6176 Field::PublicAccess => {
6177 if r#public_access_property.is_some() {
6178 return Err(<A::Error as de::Error>::duplicate_field(
6179 "publicAccess",
6180 ));
6181 }
6182 r#public_access_property = Some({
6183 struct DeserializeWith(Vec<PublicAccessProperty>);
6184 impl<'de> Deserialize<'de> for DeserializeWith {
6185 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6186 where
6187 D: Deserializer<'de>,
6188 {
6189 Ok(DeserializeWith(serde_with::As::<
6190 serde_with::OneOrMany<serde_with::Same>,
6191 >::deserialize(deserializer)?))
6192 }
6193 }
6194 match map.next_value::<DeserializeWith>() {
6195 Ok(deserialize_with) => deserialize_with.0,
6196 Err(err) => {
6197 return Err(err);
6198 }
6199 }
6200 });
6201 }
6202 Field::SmokingAllowed => {
6203 if r#smoking_allowed_property.is_some() {
6204 return Err(<A::Error as de::Error>::duplicate_field(
6205 "smokingAllowed",
6206 ));
6207 }
6208 r#smoking_allowed_property = Some({
6209 struct DeserializeWith(Vec<SmokingAllowedProperty>);
6210 impl<'de> Deserialize<'de> for DeserializeWith {
6211 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6212 where
6213 D: Deserializer<'de>,
6214 {
6215 Ok(DeserializeWith(serde_with::As::<
6216 serde_with::OneOrMany<serde_with::Same>,
6217 >::deserialize(deserializer)?))
6218 }
6219 }
6220 match map.next_value::<DeserializeWith>() {
6221 Ok(deserialize_with) => deserialize_with.0,
6222 Err(err) => {
6223 return Err(err);
6224 }
6225 }
6226 });
6227 }
6228 Field::SpecialOpeningHoursSpecification => {
6229 if r#special_opening_hours_specification_property.is_some() {
6230 return Err(<A::Error as de::Error>::duplicate_field(
6231 "specialOpeningHoursSpecification",
6232 ));
6233 }
6234 r#special_opening_hours_specification_property = Some({
6235 struct DeserializeWith(
6236 Vec<SpecialOpeningHoursSpecificationProperty>,
6237 );
6238 impl<'de> Deserialize<'de> for DeserializeWith {
6239 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6240 where
6241 D: Deserializer<'de>,
6242 {
6243 Ok(DeserializeWith(serde_with::As::<
6244 serde_with::OneOrMany<serde_with::Same>,
6245 >::deserialize(deserializer)?))
6246 }
6247 }
6248 match map.next_value::<DeserializeWith>() {
6249 Ok(deserialize_with) => deserialize_with.0,
6250 Err(err) => {
6251 return Err(err);
6252 }
6253 }
6254 });
6255 }
6256 Field::TourBookingPage => {
6257 if r#tour_booking_page_property.is_some() {
6258 return Err(<A::Error as de::Error>::duplicate_field(
6259 "tourBookingPage",
6260 ));
6261 }
6262 r#tour_booking_page_property = Some({
6263 struct DeserializeWith(Vec<TourBookingPageProperty>);
6264 impl<'de> Deserialize<'de> for DeserializeWith {
6265 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6266 where
6267 D: Deserializer<'de>,
6268 {
6269 Ok(DeserializeWith(serde_with::As::<
6270 serde_with::OneOrMany<serde_with::Same>,
6271 >::deserialize(deserializer)?))
6272 }
6273 }
6274 match map.next_value::<DeserializeWith>() {
6275 Ok(deserialize_with) => deserialize_with.0,
6276 Err(err) => {
6277 return Err(err);
6278 }
6279 }
6280 });
6281 }
6282 Field::AdditionalType => {
6283 if r#additional_type_property.is_some() {
6284 return Err(<A::Error as de::Error>::duplicate_field(
6285 "additionalType",
6286 ));
6287 }
6288 r#additional_type_property = Some({
6289 struct DeserializeWith(Vec<AdditionalTypeProperty>);
6290 impl<'de> Deserialize<'de> for DeserializeWith {
6291 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6292 where
6293 D: Deserializer<'de>,
6294 {
6295 Ok(DeserializeWith(serde_with::As::<
6296 serde_with::OneOrMany<serde_with::Same>,
6297 >::deserialize(deserializer)?))
6298 }
6299 }
6300 match map.next_value::<DeserializeWith>() {
6301 Ok(deserialize_with) => deserialize_with.0,
6302 Err(err) => {
6303 return Err(err);
6304 }
6305 }
6306 });
6307 }
6308 Field::AlternateName => {
6309 if r#alternate_name_property.is_some() {
6310 return Err(<A::Error as de::Error>::duplicate_field(
6311 "alternateName",
6312 ));
6313 }
6314 r#alternate_name_property = Some({
6315 struct DeserializeWith(Vec<AlternateNameProperty>);
6316 impl<'de> Deserialize<'de> for DeserializeWith {
6317 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6318 where
6319 D: Deserializer<'de>,
6320 {
6321 Ok(DeserializeWith(serde_with::As::<
6322 serde_with::OneOrMany<serde_with::Same>,
6323 >::deserialize(deserializer)?))
6324 }
6325 }
6326 match map.next_value::<DeserializeWith>() {
6327 Ok(deserialize_with) => deserialize_with.0,
6328 Err(err) => {
6329 return Err(err);
6330 }
6331 }
6332 });
6333 }
6334 Field::Description => {
6335 if r#description_property.is_some() {
6336 return Err(<A::Error as de::Error>::duplicate_field(
6337 "description",
6338 ));
6339 }
6340 r#description_property = Some({
6341 struct DeserializeWith(Vec<DescriptionProperty>);
6342 impl<'de> Deserialize<'de> for DeserializeWith {
6343 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6344 where
6345 D: Deserializer<'de>,
6346 {
6347 Ok(DeserializeWith(serde_with::As::<
6348 serde_with::OneOrMany<serde_with::Same>,
6349 >::deserialize(deserializer)?))
6350 }
6351 }
6352 match map.next_value::<DeserializeWith>() {
6353 Ok(deserialize_with) => deserialize_with.0,
6354 Err(err) => {
6355 return Err(err);
6356 }
6357 }
6358 });
6359 }
6360 Field::DisambiguatingDescription => {
6361 if r#disambiguating_description_property.is_some() {
6362 return Err(<A::Error as de::Error>::duplicate_field(
6363 "disambiguatingDescription",
6364 ));
6365 }
6366 r#disambiguating_description_property = Some({
6367 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
6368 impl<'de> Deserialize<'de> for DeserializeWith {
6369 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6370 where
6371 D: Deserializer<'de>,
6372 {
6373 Ok(DeserializeWith(serde_with::As::<
6374 serde_with::OneOrMany<serde_with::Same>,
6375 >::deserialize(deserializer)?))
6376 }
6377 }
6378 match map.next_value::<DeserializeWith>() {
6379 Ok(deserialize_with) => deserialize_with.0,
6380 Err(err) => {
6381 return Err(err);
6382 }
6383 }
6384 });
6385 }
6386 Field::Identifier => {
6387 if r#identifier_property.is_some() {
6388 return Err(<A::Error as de::Error>::duplicate_field(
6389 "identifier",
6390 ));
6391 }
6392 r#identifier_property = Some({
6393 struct DeserializeWith(Vec<IdentifierProperty>);
6394 impl<'de> Deserialize<'de> for DeserializeWith {
6395 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6396 where
6397 D: Deserializer<'de>,
6398 {
6399 Ok(DeserializeWith(serde_with::As::<
6400 serde_with::OneOrMany<serde_with::Same>,
6401 >::deserialize(deserializer)?))
6402 }
6403 }
6404 match map.next_value::<DeserializeWith>() {
6405 Ok(deserialize_with) => deserialize_with.0,
6406 Err(err) => {
6407 return Err(err);
6408 }
6409 }
6410 });
6411 }
6412 Field::Image => {
6413 if r#image_property.is_some() {
6414 return Err(<A::Error as de::Error>::duplicate_field("image"));
6415 }
6416 r#image_property = Some({
6417 struct DeserializeWith(Vec<ImageProperty>);
6418 impl<'de> Deserialize<'de> for DeserializeWith {
6419 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6420 where
6421 D: Deserializer<'de>,
6422 {
6423 Ok(DeserializeWith(serde_with::As::<
6424 serde_with::OneOrMany<serde_with::Same>,
6425 >::deserialize(deserializer)?))
6426 }
6427 }
6428 match map.next_value::<DeserializeWith>() {
6429 Ok(deserialize_with) => deserialize_with.0,
6430 Err(err) => {
6431 return Err(err);
6432 }
6433 }
6434 });
6435 }
6436 Field::MainEntityOfPage => {
6437 if r#main_entity_of_page_property.is_some() {
6438 return Err(<A::Error as de::Error>::duplicate_field(
6439 "mainEntityOfPage",
6440 ));
6441 }
6442 r#main_entity_of_page_property = Some({
6443 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
6444 impl<'de> Deserialize<'de> for DeserializeWith {
6445 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6446 where
6447 D: Deserializer<'de>,
6448 {
6449 Ok(DeserializeWith(serde_with::As::<
6450 serde_with::OneOrMany<serde_with::Same>,
6451 >::deserialize(deserializer)?))
6452 }
6453 }
6454 match map.next_value::<DeserializeWith>() {
6455 Ok(deserialize_with) => deserialize_with.0,
6456 Err(err) => {
6457 return Err(err);
6458 }
6459 }
6460 });
6461 }
6462 Field::Name => {
6463 if r#name_property.is_some() {
6464 return Err(<A::Error as de::Error>::duplicate_field("name"));
6465 }
6466 r#name_property = Some({
6467 struct DeserializeWith(Vec<NameProperty>);
6468 impl<'de> Deserialize<'de> for DeserializeWith {
6469 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6470 where
6471 D: Deserializer<'de>,
6472 {
6473 Ok(DeserializeWith(serde_with::As::<
6474 serde_with::OneOrMany<serde_with::Same>,
6475 >::deserialize(deserializer)?))
6476 }
6477 }
6478 match map.next_value::<DeserializeWith>() {
6479 Ok(deserialize_with) => deserialize_with.0,
6480 Err(err) => {
6481 return Err(err);
6482 }
6483 }
6484 });
6485 }
6486 Field::PotentialAction => {
6487 if r#potential_action_property.is_some() {
6488 return Err(<A::Error as de::Error>::duplicate_field(
6489 "potentialAction",
6490 ));
6491 }
6492 r#potential_action_property = Some({
6493 struct DeserializeWith(Vec<PotentialActionProperty>);
6494 impl<'de> Deserialize<'de> for DeserializeWith {
6495 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6496 where
6497 D: Deserializer<'de>,
6498 {
6499 Ok(DeserializeWith(serde_with::As::<
6500 serde_with::OneOrMany<serde_with::Same>,
6501 >::deserialize(deserializer)?))
6502 }
6503 }
6504 match map.next_value::<DeserializeWith>() {
6505 Ok(deserialize_with) => deserialize_with.0,
6506 Err(err) => {
6507 return Err(err);
6508 }
6509 }
6510 });
6511 }
6512 Field::SameAs => {
6513 if r#same_as_property.is_some() {
6514 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
6515 }
6516 r#same_as_property = Some({
6517 struct DeserializeWith(Vec<SameAsProperty>);
6518 impl<'de> Deserialize<'de> for DeserializeWith {
6519 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6520 where
6521 D: Deserializer<'de>,
6522 {
6523 Ok(DeserializeWith(serde_with::As::<
6524 serde_with::OneOrMany<serde_with::Same>,
6525 >::deserialize(deserializer)?))
6526 }
6527 }
6528 match map.next_value::<DeserializeWith>() {
6529 Ok(deserialize_with) => deserialize_with.0,
6530 Err(err) => {
6531 return Err(err);
6532 }
6533 }
6534 });
6535 }
6536 Field::SubjectOf => {
6537 if r#subject_of_property.is_some() {
6538 return Err(<A::Error as de::Error>::duplicate_field(
6539 "subjectOf",
6540 ));
6541 }
6542 r#subject_of_property = Some({
6543 struct DeserializeWith(Vec<SubjectOfProperty>);
6544 impl<'de> Deserialize<'de> for DeserializeWith {
6545 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6546 where
6547 D: Deserializer<'de>,
6548 {
6549 Ok(DeserializeWith(serde_with::As::<
6550 serde_with::OneOrMany<serde_with::Same>,
6551 >::deserialize(deserializer)?))
6552 }
6553 }
6554 match map.next_value::<DeserializeWith>() {
6555 Ok(deserialize_with) => deserialize_with.0,
6556 Err(err) => {
6557 return Err(err);
6558 }
6559 }
6560 });
6561 }
6562 Field::Url => {
6563 if r#url_property.is_some() {
6564 return Err(<A::Error as de::Error>::duplicate_field("url"));
6565 }
6566 r#url_property = Some({
6567 struct DeserializeWith(Vec<UrlProperty>);
6568 impl<'de> Deserialize<'de> for DeserializeWith {
6569 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6570 where
6571 D: Deserializer<'de>,
6572 {
6573 Ok(DeserializeWith(serde_with::As::<
6574 serde_with::OneOrMany<serde_with::Same>,
6575 >::deserialize(deserializer)?))
6576 }
6577 }
6578 match map.next_value::<DeserializeWith>() {
6579 Ok(deserialize_with) => deserialize_with.0,
6580 Err(err) => {
6581 return Err(err);
6582 }
6583 }
6584 });
6585 }
6586 Field::Ignore => {
6587 let _ = map.next_value::<de::IgnoredAny>()?;
6588 }
6589 }
6590 }
6591 Ok(Preschool {
6592 r#opening_hours: r#opening_hours_property.unwrap_or_default(),
6593 r#alumni: r#alumni_property.unwrap_or_default(),
6594 r#actionable_feedback_policy: r#actionable_feedback_policy_property
6595 .unwrap_or_default(),
6596 r#address: r#address_property.unwrap_or_default(),
6597 r#agent_interaction_statistic: r#agent_interaction_statistic_property
6598 .unwrap_or_default(),
6599 r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
6600 r#area_served: r#area_served_property.unwrap_or_default(),
6601 r#award: r#award_property.unwrap_or_default(),
6602 r#awards: r#awards_property.unwrap_or_default(),
6603 r#brand: r#brand_property.unwrap_or_default(),
6604 r#contact_point: r#contact_point_property.unwrap_or_default(),
6605 r#contact_points: r#contact_points_property.unwrap_or_default(),
6606 r#corrections_policy: r#corrections_policy_property.unwrap_or_default(),
6607 r#department: r#department_property.unwrap_or_default(),
6608 r#dissolution_date: r#dissolution_date_property.unwrap_or_default(),
6609 r#diversity_policy: r#diversity_policy_property.unwrap_or_default(),
6610 r#diversity_staffing_report: r#diversity_staffing_report_property
6611 .unwrap_or_default(),
6612 r#duns: r#duns_property.unwrap_or_default(),
6613 r#email: r#email_property.unwrap_or_default(),
6614 r#employee: r#employee_property.unwrap_or_default(),
6615 r#employees: r#employees_property.unwrap_or_default(),
6616 r#ethics_policy: r#ethics_policy_property.unwrap_or_default(),
6617 r#event: r#event_property.unwrap_or_default(),
6618 r#events: r#events_property.unwrap_or_default(),
6619 r#fax_number: r#fax_number_property.unwrap_or_default(),
6620 r#founder: r#founder_property.unwrap_or_default(),
6621 r#founders: r#founders_property.unwrap_or_default(),
6622 r#founding_date: r#founding_date_property.unwrap_or_default(),
6623 r#founding_location: r#founding_location_property.unwrap_or_default(),
6624 r#funder: r#funder_property.unwrap_or_default(),
6625 r#funding: r#funding_property.unwrap_or_default(),
6626 r#global_location_number: r#global_location_number_property
6627 .unwrap_or_default(),
6628 r#has_credential: r#has_credential_property.unwrap_or_default(),
6629 r#has_merchant_return_policy: r#has_merchant_return_policy_property
6630 .unwrap_or_default(),
6631 r#has_offer_catalog: r#has_offer_catalog_property.unwrap_or_default(),
6632 r#has_pos: r#has_pos_property.unwrap_or_default(),
6633 r#has_product_return_policy: r#has_product_return_policy_property
6634 .unwrap_or_default(),
6635 r#interaction_statistic: r#interaction_statistic_property
6636 .unwrap_or_default(),
6637 r#isic_v_4: r#isic_v_4_property.unwrap_or_default(),
6638 r#iso_6523_code: r#iso_6523_code_property.unwrap_or_default(),
6639 r#keywords: r#keywords_property.unwrap_or_default(),
6640 r#knows_about: r#knows_about_property.unwrap_or_default(),
6641 r#knows_language: r#knows_language_property.unwrap_or_default(),
6642 r#legal_name: r#legal_name_property.unwrap_or_default(),
6643 r#lei_code: r#lei_code_property.unwrap_or_default(),
6644 r#location: r#location_property.unwrap_or_default(),
6645 r#logo: r#logo_property.unwrap_or_default(),
6646 r#makes_offer: r#makes_offer_property.unwrap_or_default(),
6647 r#member: r#member_property.unwrap_or_default(),
6648 r#member_of: r#member_of_property.unwrap_or_default(),
6649 r#members: r#members_property.unwrap_or_default(),
6650 r#naics: r#naics_property.unwrap_or_default(),
6651 r#nonprofit_status: r#nonprofit_status_property.unwrap_or_default(),
6652 r#number_of_employees: r#number_of_employees_property.unwrap_or_default(),
6653 r#ownership_funding_info: r#ownership_funding_info_property
6654 .unwrap_or_default(),
6655 r#owns: r#owns_property.unwrap_or_default(),
6656 r#parent_organization: r#parent_organization_property.unwrap_or_default(),
6657 r#publishing_principles: r#publishing_principles_property
6658 .unwrap_or_default(),
6659 r#review: r#review_property.unwrap_or_default(),
6660 r#reviews: r#reviews_property.unwrap_or_default(),
6661 r#seeks: r#seeks_property.unwrap_or_default(),
6662 r#service_area: r#service_area_property.unwrap_or_default(),
6663 r#slogan: r#slogan_property.unwrap_or_default(),
6664 r#sponsor: r#sponsor_property.unwrap_or_default(),
6665 r#sub_organization: r#sub_organization_property.unwrap_or_default(),
6666 r#tax_id: r#tax_id_property.unwrap_or_default(),
6667 r#telephone: r#telephone_property.unwrap_or_default(),
6668 r#unnamed_sources_policy: r#unnamed_sources_policy_property
6669 .unwrap_or_default(),
6670 r#vat_id: r#vat_id_property.unwrap_or_default(),
6671 r#additional_property: r#additional_property_property.unwrap_or_default(),
6672 r#amenity_feature: r#amenity_feature_property.unwrap_or_default(),
6673 r#branch_code: r#branch_code_property.unwrap_or_default(),
6674 r#contained_in: r#contained_in_property.unwrap_or_default(),
6675 r#contained_in_place: r#contained_in_place_property.unwrap_or_default(),
6676 r#contains_place: r#contains_place_property.unwrap_or_default(),
6677 r#geo: r#geo_property.unwrap_or_default(),
6678 r#geo_contains: r#geo_contains_property.unwrap_or_default(),
6679 r#geo_covered_by: r#geo_covered_by_property.unwrap_or_default(),
6680 r#geo_covers: r#geo_covers_property.unwrap_or_default(),
6681 r#geo_crosses: r#geo_crosses_property.unwrap_or_default(),
6682 r#geo_disjoint: r#geo_disjoint_property.unwrap_or_default(),
6683 r#geo_equals: r#geo_equals_property.unwrap_or_default(),
6684 r#geo_intersects: r#geo_intersects_property.unwrap_or_default(),
6685 r#geo_overlaps: r#geo_overlaps_property.unwrap_or_default(),
6686 r#geo_touches: r#geo_touches_property.unwrap_or_default(),
6687 r#geo_within: r#geo_within_property.unwrap_or_default(),
6688 r#has_drive_through_service: r#has_drive_through_service_property
6689 .unwrap_or_default(),
6690 r#has_map: r#has_map_property.unwrap_or_default(),
6691 r#is_accessible_for_free: r#is_accessible_for_free_property
6692 .unwrap_or_default(),
6693 r#latitude: r#latitude_property.unwrap_or_default(),
6694 r#longitude: r#longitude_property.unwrap_or_default(),
6695 r#map: r#map_property.unwrap_or_default(),
6696 r#maps: r#maps_property.unwrap_or_default(),
6697 r#maximum_attendee_capacity: r#maximum_attendee_capacity_property
6698 .unwrap_or_default(),
6699 r#opening_hours_specification: r#opening_hours_specification_property
6700 .unwrap_or_default(),
6701 r#photo: r#photo_property.unwrap_or_default(),
6702 r#photos: r#photos_property.unwrap_or_default(),
6703 r#public_access: r#public_access_property.unwrap_or_default(),
6704 r#smoking_allowed: r#smoking_allowed_property.unwrap_or_default(),
6705 r#special_opening_hours_specification:
6706 r#special_opening_hours_specification_property.unwrap_or_default(),
6707 r#tour_booking_page: r#tour_booking_page_property.unwrap_or_default(),
6708 r#additional_type: r#additional_type_property.unwrap_or_default(),
6709 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
6710 r#description: r#description_property.unwrap_or_default(),
6711 r#disambiguating_description: r#disambiguating_description_property
6712 .unwrap_or_default(),
6713 r#identifier: r#identifier_property.unwrap_or_default(),
6714 r#image: r#image_property.unwrap_or_default(),
6715 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
6716 r#name: r#name_property.unwrap_or_default(),
6717 r#potential_action: r#potential_action_property.unwrap_or_default(),
6718 r#same_as: r#same_as_property.unwrap_or_default(),
6719 r#subject_of: r#subject_of_property.unwrap_or_default(),
6720 r#url: r#url_property.unwrap_or_default(),
6721 })
6722 }
6723 }
6724 const FIELDS: &[&str] = &[
6725 "openingHours",
6726 "alumni",
6727 "actionableFeedbackPolicy",
6728 "address",
6729 "agentInteractionStatistic",
6730 "aggregateRating",
6731 "areaServed",
6732 "award",
6733 "awards",
6734 "brand",
6735 "contactPoint",
6736 "contactPoints",
6737 "correctionsPolicy",
6738 "department",
6739 "dissolutionDate",
6740 "diversityPolicy",
6741 "diversityStaffingReport",
6742 "duns",
6743 "email",
6744 "employee",
6745 "employees",
6746 "ethicsPolicy",
6747 "event",
6748 "events",
6749 "faxNumber",
6750 "founder",
6751 "founders",
6752 "foundingDate",
6753 "foundingLocation",
6754 "funder",
6755 "funding",
6756 "globalLocationNumber",
6757 "hasCredential",
6758 "hasMerchantReturnPolicy",
6759 "hasOfferCatalog",
6760 "hasPOS",
6761 "hasProductReturnPolicy",
6762 "interactionStatistic",
6763 "isicV4",
6764 "iso6523Code",
6765 "keywords",
6766 "knowsAbout",
6767 "knowsLanguage",
6768 "legalName",
6769 "leiCode",
6770 "location",
6771 "logo",
6772 "makesOffer",
6773 "member",
6774 "memberOf",
6775 "members",
6776 "naics",
6777 "nonprofitStatus",
6778 "numberOfEmployees",
6779 "ownershipFundingInfo",
6780 "owns",
6781 "parentOrganization",
6782 "publishingPrinciples",
6783 "review",
6784 "reviews",
6785 "seeks",
6786 "serviceArea",
6787 "slogan",
6788 "sponsor",
6789 "subOrganization",
6790 "taxID",
6791 "telephone",
6792 "unnamedSourcesPolicy",
6793 "vatID",
6794 "additionalProperty",
6795 "amenityFeature",
6796 "branchCode",
6797 "containedIn",
6798 "containedInPlace",
6799 "containsPlace",
6800 "geo",
6801 "geoContains",
6802 "geoCoveredBy",
6803 "geoCovers",
6804 "geoCrosses",
6805 "geoDisjoint",
6806 "geoEquals",
6807 "geoIntersects",
6808 "geoOverlaps",
6809 "geoTouches",
6810 "geoWithin",
6811 "hasDriveThroughService",
6812 "hasMap",
6813 "isAccessibleForFree",
6814 "latitude",
6815 "longitude",
6816 "map",
6817 "maps",
6818 "maximumAttendeeCapacity",
6819 "openingHoursSpecification",
6820 "photo",
6821 "photos",
6822 "publicAccess",
6823 "smokingAllowed",
6824 "specialOpeningHoursSpecification",
6825 "tourBookingPage",
6826 "additionalType",
6827 "alternateName",
6828 "description",
6829 "disambiguatingDescription",
6830 "identifier",
6831 "image",
6832 "mainEntityOfPage",
6833 "name",
6834 "potentialAction",
6835 "sameAs",
6836 "subjectOf",
6837 "url",
6838 ];
6839 deserializer.deserialize_struct("Preschool", FIELDS, ClassVisitor)
6840 }
6841 }
6842}