schema_org_types/schemas/classes/
motel.rs

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

schema_org_types/schemas/classes/
motel.rs
