schema_org_types/schemas/classes/
exercise_gym.rs

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

schema_org_types/schemas/classes/
exercise_gym.rs
