schema_org_types/schemas/classes/
vacation_rental.rs

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

schema_org_types/schemas/classes/
vacation_rental.rs
