schema_org_types/schemas/classes/
educational_organization.rs

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

schema_org_types/schemas/classes/
educational_organization.rs
