schema_org_types/schemas/classes/
campground.rs

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

schema_org_types/schemas/classes/
campground.rs
