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