schema_org_types/schemas/classes/
place.rs

1use super::*;
2/// <https://schema.org/Place>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct Place {
6	/// <https://schema.org/additionalProperty>
7	pub r#additional_property: Vec<AdditionalPropertyProperty>,
8	/// <https://schema.org/address>
9	pub r#address: Vec<AddressProperty>,
10	/// <https://schema.org/aggregateRating>
11	pub r#aggregate_rating: Vec<AggregateRatingProperty>,
12	/// <https://schema.org/amenityFeature>
13	pub r#amenity_feature: Vec<AmenityFeatureProperty>,
14	/// <https://schema.org/branchCode>
15	pub r#branch_code: Vec<BranchCodeProperty>,
16	/// <https://schema.org/containedIn>
17	#[deprecated = "This schema is superseded by <https://schema.org/containedInPlace>."]
18	pub r#contained_in: Vec<ContainedInProperty>,
19	/// <https://schema.org/containedInPlace>
20	pub r#contained_in_place: Vec<ContainedInPlaceProperty>,
21	/// <https://schema.org/containsPlace>
22	pub r#contains_place: Vec<ContainsPlaceProperty>,
23	/// <https://schema.org/event>
24	pub r#event: Vec<EventProperty>,
25	/// <https://schema.org/events>
26	#[deprecated = "This schema is superseded by <https://schema.org/event>."]
27	pub r#events: Vec<EventsProperty>,
28	/// <https://schema.org/faxNumber>
29	pub r#fax_number: Vec<FaxNumberProperty>,
30	/// <https://schema.org/geo>
31	pub r#geo: Vec<GeoProperty>,
32	/// <https://schema.org/geoContains>
33	pub r#geo_contains: Vec<GeoContainsProperty>,
34	/// <https://schema.org/geoCoveredBy>
35	pub r#geo_covered_by: Vec<GeoCoveredByProperty>,
36	/// <https://schema.org/geoCovers>
37	pub r#geo_covers: Vec<GeoCoversProperty>,
38	/// <https://schema.org/geoCrosses>
39	pub r#geo_crosses: Vec<GeoCrossesProperty>,
40	/// <https://schema.org/geoDisjoint>
41	pub r#geo_disjoint: Vec<GeoDisjointProperty>,
42	/// <https://schema.org/geoEquals>
43	pub r#geo_equals: Vec<GeoEqualsProperty>,
44	/// <https://schema.org/geoIntersects>
45	pub r#geo_intersects: Vec<GeoIntersectsProperty>,
46	/// <https://schema.org/geoOverlaps>
47	pub r#geo_overlaps: Vec<GeoOverlapsProperty>,
48	/// <https://schema.org/geoTouches>
49	pub r#geo_touches: Vec<GeoTouchesProperty>,
50	/// <https://schema.org/geoWithin>
51	pub r#geo_within: Vec<GeoWithinProperty>,
52	/// <https://schema.org/globalLocationNumber>
53	pub r#global_location_number: Vec<GlobalLocationNumberProperty>,
54	/// <https://schema.org/hasDriveThroughService>
55	pub r#has_drive_through_service: Vec<HasDriveThroughServiceProperty>,
56	/// <https://schema.org/hasMap>
57	pub r#has_map: Vec<HasMapProperty>,
58	/// <https://schema.org/isAccessibleForFree>
59	pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
60	/// <https://schema.org/isicV4>
61	pub r#isic_v_4: Vec<IsicV4Property>,
62	/// <https://schema.org/keywords>
63	pub r#keywords: Vec<KeywordsProperty>,
64	/// <https://schema.org/latitude>
65	pub r#latitude: Vec<LatitudeProperty>,
66	/// <https://schema.org/logo>
67	pub r#logo: Vec<LogoProperty>,
68	/// <https://schema.org/longitude>
69	pub r#longitude: Vec<LongitudeProperty>,
70	/// <https://schema.org/map>
71	#[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
72	pub r#map: Vec<MapProperty>,
73	/// <https://schema.org/maps>
74	#[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
75	pub r#maps: Vec<MapsProperty>,
76	/// <https://schema.org/maximumAttendeeCapacity>
77	pub r#maximum_attendee_capacity: Vec<MaximumAttendeeCapacityProperty>,
78	/// <https://schema.org/openingHoursSpecification>
79	pub r#opening_hours_specification: Vec<OpeningHoursSpecificationProperty>,
80	/// <https://schema.org/photo>
81	pub r#photo: Vec<PhotoProperty>,
82	/// <https://schema.org/photos>
83	#[deprecated = "This schema is superseded by <https://schema.org/photo>."]
84	pub r#photos: Vec<PhotosProperty>,
85	/// <https://schema.org/publicAccess>
86	pub r#public_access: Vec<PublicAccessProperty>,
87	/// <https://schema.org/review>
88	pub r#review: Vec<ReviewProperty>,
89	/// <https://schema.org/reviews>
90	#[deprecated = "This schema is superseded by <https://schema.org/review>."]
91	pub r#reviews: Vec<ReviewsProperty>,
92	/// <https://schema.org/slogan>
93	pub r#slogan: Vec<SloganProperty>,
94	/// <https://schema.org/smokingAllowed>
95	pub r#smoking_allowed: Vec<SmokingAllowedProperty>,
96	/// <https://schema.org/specialOpeningHoursSpecification>
97	pub r#special_opening_hours_specification: Vec<SpecialOpeningHoursSpecificationProperty>,
98	/// <https://schema.org/telephone>
99	pub r#telephone: Vec<TelephoneProperty>,
100	/// <https://schema.org/tourBookingPage>
101	pub r#tour_booking_page: Vec<TourBookingPageProperty>,
102	/// <https://schema.org/additionalType>
103	pub r#additional_type: Vec<AdditionalTypeProperty>,
104	/// <https://schema.org/alternateName>
105	pub r#alternate_name: Vec<AlternateNameProperty>,
106	/// <https://schema.org/description>
107	pub r#description: Vec<DescriptionProperty>,
108	/// <https://schema.org/disambiguatingDescription>
109	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
110	/// <https://schema.org/identifier>
111	pub r#identifier: Vec<IdentifierProperty>,
112	/// <https://schema.org/image>
113	pub r#image: Vec<ImageProperty>,
114	/// <https://schema.org/mainEntityOfPage>
115	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
116	/// <https://schema.org/name>
117	pub r#name: Vec<NameProperty>,
118	/// <https://schema.org/potentialAction>
119	pub r#potential_action: Vec<PotentialActionProperty>,
120	/// <https://schema.org/sameAs>
121	pub r#same_as: Vec<SameAsProperty>,
122	/// <https://schema.org/subjectOf>
123	pub r#subject_of: Vec<SubjectOfProperty>,
124	/// <https://schema.org/url>
125	pub r#url: Vec<UrlProperty>,
126}
127/// This trait is for properties from <https://schema.org/Place>.
128pub trait PlaceTrait {
129	/// Get <https://schema.org/additionalProperty> from [`Self`] as borrowed slice.
130	fn get_additional_property(&self) -> &[AdditionalPropertyProperty];
131	/// Take <https://schema.org/additionalProperty> from [`Self`] as owned vector.
132	fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty>;
133	/// Get <https://schema.org/address> from [`Self`] as borrowed slice.
134	fn get_address(&self) -> &[AddressProperty];
135	/// Take <https://schema.org/address> from [`Self`] as owned vector.
136	fn take_address(&mut self) -> Vec<AddressProperty>;
137	/// Get <https://schema.org/aggregateRating> from [`Self`] as borrowed slice.
138	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty];
139	/// Take <https://schema.org/aggregateRating> from [`Self`] as owned vector.
140	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty>;
141	/// Get <https://schema.org/amenityFeature> from [`Self`] as borrowed slice.
142	fn get_amenity_feature(&self) -> &[AmenityFeatureProperty];
143	/// Take <https://schema.org/amenityFeature> from [`Self`] as owned vector.
144	fn take_amenity_feature(&mut self) -> Vec<AmenityFeatureProperty>;
145	/// Get <https://schema.org/branchCode> from [`Self`] as borrowed slice.
146	fn get_branch_code(&self) -> &[BranchCodeProperty];
147	/// Take <https://schema.org/branchCode> from [`Self`] as owned vector.
148	fn take_branch_code(&mut self) -> Vec<BranchCodeProperty>;
149	/// Get <https://schema.org/containedIn> from [`Self`] as borrowed slice.
150	#[deprecated = "This schema is superseded by <https://schema.org/containedInPlace>."]
151	fn get_contained_in(&self) -> &[ContainedInProperty];
152	/// Take <https://schema.org/containedIn> from [`Self`] as owned vector.
153	#[deprecated = "This schema is superseded by <https://schema.org/containedInPlace>."]
154	fn take_contained_in(&mut self) -> Vec<ContainedInProperty>;
155	/// Get <https://schema.org/containedInPlace> from [`Self`] as borrowed slice.
156	fn get_contained_in_place(&self) -> &[ContainedInPlaceProperty];
157	/// Take <https://schema.org/containedInPlace> from [`Self`] as owned vector.
158	fn take_contained_in_place(&mut self) -> Vec<ContainedInPlaceProperty>;
159	/// Get <https://schema.org/containsPlace> from [`Self`] as borrowed slice.
160	fn get_contains_place(&self) -> &[ContainsPlaceProperty];
161	/// Take <https://schema.org/containsPlace> from [`Self`] as owned vector.
162	fn take_contains_place(&mut self) -> Vec<ContainsPlaceProperty>;
163	/// Get <https://schema.org/event> from [`Self`] as borrowed slice.
164	fn get_event(&self) -> &[EventProperty];
165	/// Take <https://schema.org/event> from [`Self`] as owned vector.
166	fn take_event(&mut self) -> Vec<EventProperty>;
167	/// Get <https://schema.org/events> from [`Self`] as borrowed slice.
168	#[deprecated = "This schema is superseded by <https://schema.org/event>."]
169	fn get_events(&self) -> &[EventsProperty];
170	/// Take <https://schema.org/events> from [`Self`] as owned vector.
171	#[deprecated = "This schema is superseded by <https://schema.org/event>."]
172	fn take_events(&mut self) -> Vec<EventsProperty>;
173	/// Get <https://schema.org/faxNumber> from [`Self`] as borrowed slice.
174	fn get_fax_number(&self) -> &[FaxNumberProperty];
175	/// Take <https://schema.org/faxNumber> from [`Self`] as owned vector.
176	fn take_fax_number(&mut self) -> Vec<FaxNumberProperty>;
177	/// Get <https://schema.org/geo> from [`Self`] as borrowed slice.
178	fn get_geo(&self) -> &[GeoProperty];
179	/// Take <https://schema.org/geo> from [`Self`] as owned vector.
180	fn take_geo(&mut self) -> Vec<GeoProperty>;
181	/// Get <https://schema.org/geoContains> from [`Self`] as borrowed slice.
182	fn get_geo_contains(&self) -> &[GeoContainsProperty];
183	/// Take <https://schema.org/geoContains> from [`Self`] as owned vector.
184	fn take_geo_contains(&mut self) -> Vec<GeoContainsProperty>;
185	/// Get <https://schema.org/geoCoveredBy> from [`Self`] as borrowed slice.
186	fn get_geo_covered_by(&self) -> &[GeoCoveredByProperty];
187	/// Take <https://schema.org/geoCoveredBy> from [`Self`] as owned vector.
188	fn take_geo_covered_by(&mut self) -> Vec<GeoCoveredByProperty>;
189	/// Get <https://schema.org/geoCovers> from [`Self`] as borrowed slice.
190	fn get_geo_covers(&self) -> &[GeoCoversProperty];
191	/// Take <https://schema.org/geoCovers> from [`Self`] as owned vector.
192	fn take_geo_covers(&mut self) -> Vec<GeoCoversProperty>;
193	/// Get <https://schema.org/geoCrosses> from [`Self`] as borrowed slice.
194	fn get_geo_crosses(&self) -> &[GeoCrossesProperty];
195	/// Take <https://schema.org/geoCrosses> from [`Self`] as owned vector.
196	fn take_geo_crosses(&mut self) -> Vec<GeoCrossesProperty>;
197	/// Get <https://schema.org/geoDisjoint> from [`Self`] as borrowed slice.
198	fn get_geo_disjoint(&self) -> &[GeoDisjointProperty];
199	/// Take <https://schema.org/geoDisjoint> from [`Self`] as owned vector.
200	fn take_geo_disjoint(&mut self) -> Vec<GeoDisjointProperty>;
201	/// Get <https://schema.org/geoEquals> from [`Self`] as borrowed slice.
202	fn get_geo_equals(&self) -> &[GeoEqualsProperty];
203	/// Take <https://schema.org/geoEquals> from [`Self`] as owned vector.
204	fn take_geo_equals(&mut self) -> Vec<GeoEqualsProperty>;
205	/// Get <https://schema.org/geoIntersects> from [`Self`] as borrowed slice.
206	fn get_geo_intersects(&self) -> &[GeoIntersectsProperty];
207	/// Take <https://schema.org/geoIntersects> from [`Self`] as owned vector.
208	fn take_geo_intersects(&mut self) -> Vec<GeoIntersectsProperty>;
209	/// Get <https://schema.org/geoOverlaps> from [`Self`] as borrowed slice.
210	fn get_geo_overlaps(&self) -> &[GeoOverlapsProperty];
211	/// Take <https://schema.org/geoOverlaps> from [`Self`] as owned vector.
212	fn take_geo_overlaps(&mut self) -> Vec<GeoOverlapsProperty>;
213	/// Get <https://schema.org/geoTouches> from [`Self`] as borrowed slice.
214	fn get_geo_touches(&self) -> &[GeoTouchesProperty];
215	/// Take <https://schema.org/geoTouches> from [`Self`] as owned vector.
216	fn take_geo_touches(&mut self) -> Vec<GeoTouchesProperty>;
217	/// Get <https://schema.org/geoWithin> from [`Self`] as borrowed slice.
218	fn get_geo_within(&self) -> &[GeoWithinProperty];
219	/// Take <https://schema.org/geoWithin> from [`Self`] as owned vector.
220	fn take_geo_within(&mut self) -> Vec<GeoWithinProperty>;
221	/// Get <https://schema.org/globalLocationNumber> from [`Self`] as borrowed slice.
222	fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty];
223	/// Take <https://schema.org/globalLocationNumber> from [`Self`] as owned vector.
224	fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty>;
225	/// Get <https://schema.org/hasDriveThroughService> from [`Self`] as borrowed slice.
226	fn get_has_drive_through_service(&self) -> &[HasDriveThroughServiceProperty];
227	/// Take <https://schema.org/hasDriveThroughService> from [`Self`] as owned vector.
228	fn take_has_drive_through_service(&mut self) -> Vec<HasDriveThroughServiceProperty>;
229	/// Get <https://schema.org/hasMap> from [`Self`] as borrowed slice.
230	fn get_has_map(&self) -> &[HasMapProperty];
231	/// Take <https://schema.org/hasMap> from [`Self`] as owned vector.
232	fn take_has_map(&mut self) -> Vec<HasMapProperty>;
233	/// Get <https://schema.org/isAccessibleForFree> from [`Self`] as borrowed slice.
234	fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty];
235	/// Take <https://schema.org/isAccessibleForFree> from [`Self`] as owned vector.
236	fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty>;
237	/// Get <https://schema.org/isicV4> from [`Self`] as borrowed slice.
238	fn get_isic_v_4(&self) -> &[IsicV4Property];
239	/// Take <https://schema.org/isicV4> from [`Self`] as owned vector.
240	fn take_isic_v_4(&mut self) -> Vec<IsicV4Property>;
241	/// Get <https://schema.org/keywords> from [`Self`] as borrowed slice.
242	fn get_keywords(&self) -> &[KeywordsProperty];
243	/// Take <https://schema.org/keywords> from [`Self`] as owned vector.
244	fn take_keywords(&mut self) -> Vec<KeywordsProperty>;
245	/// Get <https://schema.org/latitude> from [`Self`] as borrowed slice.
246	fn get_latitude(&self) -> &[LatitudeProperty];
247	/// Take <https://schema.org/latitude> from [`Self`] as owned vector.
248	fn take_latitude(&mut self) -> Vec<LatitudeProperty>;
249	/// Get <https://schema.org/logo> from [`Self`] as borrowed slice.
250	fn get_logo(&self) -> &[LogoProperty];
251	/// Take <https://schema.org/logo> from [`Self`] as owned vector.
252	fn take_logo(&mut self) -> Vec<LogoProperty>;
253	/// Get <https://schema.org/longitude> from [`Self`] as borrowed slice.
254	fn get_longitude(&self) -> &[LongitudeProperty];
255	/// Take <https://schema.org/longitude> from [`Self`] as owned vector.
256	fn take_longitude(&mut self) -> Vec<LongitudeProperty>;
257	/// Get <https://schema.org/map> from [`Self`] as borrowed slice.
258	#[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
259	fn get_map(&self) -> &[MapProperty];
260	/// Take <https://schema.org/map> from [`Self`] as owned vector.
261	#[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
262	fn take_map(&mut self) -> Vec<MapProperty>;
263	/// Get <https://schema.org/maps> from [`Self`] as borrowed slice.
264	#[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
265	fn get_maps(&self) -> &[MapsProperty];
266	/// Take <https://schema.org/maps> from [`Self`] as owned vector.
267	#[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
268	fn take_maps(&mut self) -> Vec<MapsProperty>;
269	/// Get <https://schema.org/maximumAttendeeCapacity> from [`Self`] as borrowed slice.
270	fn get_maximum_attendee_capacity(&self) -> &[MaximumAttendeeCapacityProperty];
271	/// Take <https://schema.org/maximumAttendeeCapacity> from [`Self`] as owned vector.
272	fn take_maximum_attendee_capacity(&mut self) -> Vec<MaximumAttendeeCapacityProperty>;
273	/// Get <https://schema.org/openingHoursSpecification> from [`Self`] as borrowed slice.
274	fn get_opening_hours_specification(&self) -> &[OpeningHoursSpecificationProperty];
275	/// Take <https://schema.org/openingHoursSpecification> from [`Self`] as owned vector.
276	fn take_opening_hours_specification(&mut self) -> Vec<OpeningHoursSpecificationProperty>;
277	/// Get <https://schema.org/photo> from [`Self`] as borrowed slice.
278	fn get_photo(&self) -> &[PhotoProperty];
279	/// Take <https://schema.org/photo> from [`Self`] as owned vector.
280	fn take_photo(&mut self) -> Vec<PhotoProperty>;
281	/// Get <https://schema.org/photos> from [`Self`] as borrowed slice.
282	#[deprecated = "This schema is superseded by <https://schema.org/photo>."]
283	fn get_photos(&self) -> &[PhotosProperty];
284	/// Take <https://schema.org/photos> from [`Self`] as owned vector.
285	#[deprecated = "This schema is superseded by <https://schema.org/photo>."]
286	fn take_photos(&mut self) -> Vec<PhotosProperty>;
287	/// Get <https://schema.org/publicAccess> from [`Self`] as borrowed slice.
288	fn get_public_access(&self) -> &[PublicAccessProperty];
289	/// Take <https://schema.org/publicAccess> from [`Self`] as owned vector.
290	fn take_public_access(&mut self) -> Vec<PublicAccessProperty>;
291	/// Get <https://schema.org/review> from [`Self`] as borrowed slice.
292	fn get_review(&self) -> &[ReviewProperty];
293	/// Take <https://schema.org/review> from [`Self`] as owned vector.
294	fn take_review(&mut self) -> Vec<ReviewProperty>;
295	/// Get <https://schema.org/reviews> from [`Self`] as borrowed slice.
296	#[deprecated = "This schema is superseded by <https://schema.org/review>."]
297	fn get_reviews(&self) -> &[ReviewsProperty];
298	/// Take <https://schema.org/reviews> from [`Self`] as owned vector.
299	#[deprecated = "This schema is superseded by <https://schema.org/review>."]
300	fn take_reviews(&mut self) -> Vec<ReviewsProperty>;
301	/// Get <https://schema.org/slogan> from [`Self`] as borrowed slice.
302	fn get_slogan(&self) -> &[SloganProperty];
303	/// Take <https://schema.org/slogan> from [`Self`] as owned vector.
304	fn take_slogan(&mut self) -> Vec<SloganProperty>;
305	/// Get <https://schema.org/smokingAllowed> from [`Self`] as borrowed slice.
306	fn get_smoking_allowed(&self) -> &[SmokingAllowedProperty];
307	/// Take <https://schema.org/smokingAllowed> from [`Self`] as owned vector.
308	fn take_smoking_allowed(&mut self) -> Vec<SmokingAllowedProperty>;
309	/// Get <https://schema.org/specialOpeningHoursSpecification> from [`Self`] as borrowed slice.
310	fn get_special_opening_hours_specification(
311		&self,
312	) -> &[SpecialOpeningHoursSpecificationProperty];
313	/// Take <https://schema.org/specialOpeningHoursSpecification> from [`Self`] as owned vector.
314	fn take_special_opening_hours_specification(
315		&mut self,
316	) -> Vec<SpecialOpeningHoursSpecificationProperty>;
317	/// Get <https://schema.org/telephone> from [`Self`] as borrowed slice.
318	fn get_telephone(&self) -> &[TelephoneProperty];
319	/// Take <https://schema.org/telephone> from [`Self`] as owned vector.
320	fn take_telephone(&mut self) -> Vec<TelephoneProperty>;
321	/// Get <https://schema.org/tourBookingPage> from [`Self`] as borrowed slice.
322	fn get_tour_booking_page(&self) -> &[TourBookingPageProperty];
323	/// Take <https://schema.org/tourBookingPage> from [`Self`] as owned vector.
324	fn take_tour_booking_page(&mut self) -> Vec<TourBookingPageProperty>;
325}
326impl PlaceTrait for Place {
327	fn get_additional_property(&self) -> &[AdditionalPropertyProperty] {
328		self.r#additional_property.as_slice()
329	}
330	fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty> {
331		std::mem::take(&mut self.r#additional_property)
332	}
333	fn get_address(&self) -> &[AddressProperty] {
334		self.r#address.as_slice()
335	}
336	fn take_address(&mut self) -> Vec<AddressProperty> {
337		std::mem::take(&mut self.r#address)
338	}
339	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
340		self.r#aggregate_rating.as_slice()
341	}
342	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
343		std::mem::take(&mut self.r#aggregate_rating)
344	}
345	fn get_amenity_feature(&self) -> &[AmenityFeatureProperty] {
346		self.r#amenity_feature.as_slice()
347	}
348	fn take_amenity_feature(&mut self) -> Vec<AmenityFeatureProperty> {
349		std::mem::take(&mut self.r#amenity_feature)
350	}
351	fn get_branch_code(&self) -> &[BranchCodeProperty] {
352		self.r#branch_code.as_slice()
353	}
354	fn take_branch_code(&mut self) -> Vec<BranchCodeProperty> {
355		std::mem::take(&mut self.r#branch_code)
356	}
357	fn get_contained_in(&self) -> &[ContainedInProperty] {
358		self.r#contained_in.as_slice()
359	}
360	fn take_contained_in(&mut self) -> Vec<ContainedInProperty> {
361		std::mem::take(&mut self.r#contained_in)
362	}
363	fn get_contained_in_place(&self) -> &[ContainedInPlaceProperty] {
364		self.r#contained_in_place.as_slice()
365	}
366	fn take_contained_in_place(&mut self) -> Vec<ContainedInPlaceProperty> {
367		std::mem::take(&mut self.r#contained_in_place)
368	}
369	fn get_contains_place(&self) -> &[ContainsPlaceProperty] {
370		self.r#contains_place.as_slice()
371	}
372	fn take_contains_place(&mut self) -> Vec<ContainsPlaceProperty> {
373		std::mem::take(&mut self.r#contains_place)
374	}
375	fn get_event(&self) -> &[EventProperty] {
376		self.r#event.as_slice()
377	}
378	fn take_event(&mut self) -> Vec<EventProperty> {
379		std::mem::take(&mut self.r#event)
380	}
381	fn get_events(&self) -> &[EventsProperty] {
382		self.r#events.as_slice()
383	}
384	fn take_events(&mut self) -> Vec<EventsProperty> {
385		std::mem::take(&mut self.r#events)
386	}
387	fn get_fax_number(&self) -> &[FaxNumberProperty] {
388		self.r#fax_number.as_slice()
389	}
390	fn take_fax_number(&mut self) -> Vec<FaxNumberProperty> {
391		std::mem::take(&mut self.r#fax_number)
392	}
393	fn get_geo(&self) -> &[GeoProperty] {
394		self.r#geo.as_slice()
395	}
396	fn take_geo(&mut self) -> Vec<GeoProperty> {
397		std::mem::take(&mut self.r#geo)
398	}
399	fn get_geo_contains(&self) -> &[GeoContainsProperty] {
400		self.r#geo_contains.as_slice()
401	}
402	fn take_geo_contains(&mut self) -> Vec<GeoContainsProperty> {
403		std::mem::take(&mut self.r#geo_contains)
404	}
405	fn get_geo_covered_by(&self) -> &[GeoCoveredByProperty] {
406		self.r#geo_covered_by.as_slice()
407	}
408	fn take_geo_covered_by(&mut self) -> Vec<GeoCoveredByProperty> {
409		std::mem::take(&mut self.r#geo_covered_by)
410	}
411	fn get_geo_covers(&self) -> &[GeoCoversProperty] {
412		self.r#geo_covers.as_slice()
413	}
414	fn take_geo_covers(&mut self) -> Vec<GeoCoversProperty> {
415		std::mem::take(&mut self.r#geo_covers)
416	}
417	fn get_geo_crosses(&self) -> &[GeoCrossesProperty] {
418		self.r#geo_crosses.as_slice()
419	}
420	fn take_geo_crosses(&mut self) -> Vec<GeoCrossesProperty> {
421		std::mem::take(&mut self.r#geo_crosses)
422	}
423	fn get_geo_disjoint(&self) -> &[GeoDisjointProperty] {
424		self.r#geo_disjoint.as_slice()
425	}
426	fn take_geo_disjoint(&mut self) -> Vec<GeoDisjointProperty> {
427		std::mem::take(&mut self.r#geo_disjoint)
428	}
429	fn get_geo_equals(&self) -> &[GeoEqualsProperty] {
430		self.r#geo_equals.as_slice()
431	}
432	fn take_geo_equals(&mut self) -> Vec<GeoEqualsProperty> {
433		std::mem::take(&mut self.r#geo_equals)
434	}
435	fn get_geo_intersects(&self) -> &[GeoIntersectsProperty] {
436		self.r#geo_intersects.as_slice()
437	}
438	fn take_geo_intersects(&mut self) -> Vec<GeoIntersectsProperty> {
439		std::mem::take(&mut self.r#geo_intersects)
440	}
441	fn get_geo_overlaps(&self) -> &[GeoOverlapsProperty] {
442		self.r#geo_overlaps.as_slice()
443	}
444	fn take_geo_overlaps(&mut self) -> Vec<GeoOverlapsProperty> {
445		std::mem::take(&mut self.r#geo_overlaps)
446	}
447	fn get_geo_touches(&self) -> &[GeoTouchesProperty] {
448		self.r#geo_touches.as_slice()
449	}
450	fn take_geo_touches(&mut self) -> Vec<GeoTouchesProperty> {
451		std::mem::take(&mut self.r#geo_touches)
452	}
453	fn get_geo_within(&self) -> &[GeoWithinProperty] {
454		self.r#geo_within.as_slice()
455	}
456	fn take_geo_within(&mut self) -> Vec<GeoWithinProperty> {
457		std::mem::take(&mut self.r#geo_within)
458	}
459	fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty] {
460		self.r#global_location_number.as_slice()
461	}
462	fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty> {
463		std::mem::take(&mut self.r#global_location_number)
464	}
465	fn get_has_drive_through_service(&self) -> &[HasDriveThroughServiceProperty] {
466		self.r#has_drive_through_service.as_slice()
467	}
468	fn take_has_drive_through_service(&mut self) -> Vec<HasDriveThroughServiceProperty> {
469		std::mem::take(&mut self.r#has_drive_through_service)
470	}
471	fn get_has_map(&self) -> &[HasMapProperty] {
472		self.r#has_map.as_slice()
473	}
474	fn take_has_map(&mut self) -> Vec<HasMapProperty> {
475		std::mem::take(&mut self.r#has_map)
476	}
477	fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
478		self.r#is_accessible_for_free.as_slice()
479	}
480	fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
481		std::mem::take(&mut self.r#is_accessible_for_free)
482	}
483	fn get_isic_v_4(&self) -> &[IsicV4Property] {
484		self.r#isic_v_4.as_slice()
485	}
486	fn take_isic_v_4(&mut self) -> Vec<IsicV4Property> {
487		std::mem::take(&mut self.r#isic_v_4)
488	}
489	fn get_keywords(&self) -> &[KeywordsProperty] {
490		self.r#keywords.as_slice()
491	}
492	fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
493		std::mem::take(&mut self.r#keywords)
494	}
495	fn get_latitude(&self) -> &[LatitudeProperty] {
496		self.r#latitude.as_slice()
497	}
498	fn take_latitude(&mut self) -> Vec<LatitudeProperty> {
499		std::mem::take(&mut self.r#latitude)
500	}
501	fn get_logo(&self) -> &[LogoProperty] {
502		self.r#logo.as_slice()
503	}
504	fn take_logo(&mut self) -> Vec<LogoProperty> {
505		std::mem::take(&mut self.r#logo)
506	}
507	fn get_longitude(&self) -> &[LongitudeProperty] {
508		self.r#longitude.as_slice()
509	}
510	fn take_longitude(&mut self) -> Vec<LongitudeProperty> {
511		std::mem::take(&mut self.r#longitude)
512	}
513	fn get_map(&self) -> &[MapProperty] {
514		self.r#map.as_slice()
515	}
516	fn take_map(&mut self) -> Vec<MapProperty> {
517		std::mem::take(&mut self.r#map)
518	}
519	fn get_maps(&self) -> &[MapsProperty] {
520		self.r#maps.as_slice()
521	}
522	fn take_maps(&mut self) -> Vec<MapsProperty> {
523		std::mem::take(&mut self.r#maps)
524	}
525	fn get_maximum_attendee_capacity(&self) -> &[MaximumAttendeeCapacityProperty] {
526		self.r#maximum_attendee_capacity.as_slice()
527	}
528	fn take_maximum_attendee_capacity(&mut self) -> Vec<MaximumAttendeeCapacityProperty> {
529		std::mem::take(&mut self.r#maximum_attendee_capacity)
530	}
531	fn get_opening_hours_specification(&self) -> &[OpeningHoursSpecificationProperty] {
532		self.r#opening_hours_specification.as_slice()
533	}
534	fn take_opening_hours_specification(&mut self) -> Vec<OpeningHoursSpecificationProperty> {
535		std::mem::take(&mut self.r#opening_hours_specification)
536	}
537	fn get_photo(&self) -> &[PhotoProperty] {
538		self.r#photo.as_slice()
539	}
540	fn take_photo(&mut self) -> Vec<PhotoProperty> {
541		std::mem::take(&mut self.r#photo)
542	}
543	fn get_photos(&self) -> &[PhotosProperty] {
544		self.r#photos.as_slice()
545	}
546	fn take_photos(&mut self) -> Vec<PhotosProperty> {
547		std::mem::take(&mut self.r#photos)
548	}
549	fn get_public_access(&self) -> &[PublicAccessProperty] {
550		self.r#public_access.as_slice()
551	}
552	fn take_public_access(&mut self) -> Vec<PublicAccessProperty> {
553		std::mem::take(&mut self.r#public_access)
554	}
555	fn get_review(&self) -> &[ReviewProperty] {
556		self.r#review.as_slice()
557	}
558	fn take_review(&mut self) -> Vec<ReviewProperty> {
559		std::mem::take(&mut self.r#review)
560	}
561	fn get_reviews(&self) -> &[ReviewsProperty] {
562		self.r#reviews.as_slice()
563	}
564	fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
565		std::mem::take(&mut self.r#reviews)
566	}
567	fn get_slogan(&self) -> &[SloganProperty] {
568		self.r#slogan.as_slice()
569	}
570	fn take_slogan(&mut self) -> Vec<SloganProperty> {
571		std::mem::take(&mut self.r#slogan)
572	}
573	fn get_smoking_allowed(&self) -> &[SmokingAllowedProperty] {
574		self.r#smoking_allowed.as_slice()
575	}
576	fn take_smoking_allowed(&mut self) -> Vec<SmokingAllowedProperty> {
577		std::mem::take(&mut self.r#smoking_allowed)
578	}
579	fn get_special_opening_hours_specification(
580		&self,
581	) -> &[SpecialOpeningHoursSpecificationProperty] {
582		self.r#special_opening_hours_specification.as_slice()
583	}
584	fn take_special_opening_hours_specification(
585		&mut self,
586	) -> Vec<SpecialOpeningHoursSpecificationProperty> {
587		std::mem::take(&mut self.r#special_opening_hours_specification)
588	}
589	fn get_telephone(&self) -> &[TelephoneProperty] {
590		self.r#telephone.as_slice()
591	}
592	fn take_telephone(&mut self) -> Vec<TelephoneProperty> {
593		std::mem::take(&mut self.r#telephone)
594	}
595	fn get_tour_booking_page(&self) -> &[TourBookingPageProperty] {
596		self.r#tour_booking_page.as_slice()
597	}
598	fn take_tour_booking_page(&mut self) -> Vec<TourBookingPageProperty> {
599		std::mem::take(&mut self.r#tour_booking_page)
600	}
601}
602impl ThingTrait for Place {
603	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
604		self.r#additional_type.as_slice()
605	}
606	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
607		std::mem::take(&mut self.r#additional_type)
608	}
609	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
610		self.r#alternate_name.as_slice()
611	}
612	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
613		std::mem::take(&mut self.r#alternate_name)
614	}
615	fn get_description(&self) -> &[DescriptionProperty] {
616		self.r#description.as_slice()
617	}
618	fn take_description(&mut self) -> Vec<DescriptionProperty> {
619		std::mem::take(&mut self.r#description)
620	}
621	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
622		self.r#disambiguating_description.as_slice()
623	}
624	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
625		std::mem::take(&mut self.r#disambiguating_description)
626	}
627	fn get_identifier(&self) -> &[IdentifierProperty] {
628		self.r#identifier.as_slice()
629	}
630	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
631		std::mem::take(&mut self.r#identifier)
632	}
633	fn get_image(&self) -> &[ImageProperty] {
634		self.r#image.as_slice()
635	}
636	fn take_image(&mut self) -> Vec<ImageProperty> {
637		std::mem::take(&mut self.r#image)
638	}
639	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
640		self.r#main_entity_of_page.as_slice()
641	}
642	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
643		std::mem::take(&mut self.r#main_entity_of_page)
644	}
645	fn get_name(&self) -> &[NameProperty] {
646		self.r#name.as_slice()
647	}
648	fn take_name(&mut self) -> Vec<NameProperty> {
649		std::mem::take(&mut self.r#name)
650	}
651	fn get_potential_action(&self) -> &[PotentialActionProperty] {
652		self.r#potential_action.as_slice()
653	}
654	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
655		std::mem::take(&mut self.r#potential_action)
656	}
657	fn get_same_as(&self) -> &[SameAsProperty] {
658		self.r#same_as.as_slice()
659	}
660	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
661		std::mem::take(&mut self.r#same_as)
662	}
663	fn get_subject_of(&self) -> &[SubjectOfProperty] {
664		self.r#subject_of.as_slice()
665	}
666	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
667		std::mem::take(&mut self.r#subject_of)
668	}
669	fn get_url(&self) -> &[UrlProperty] {
670		self.r#url.as_slice()
671	}
672	fn take_url(&mut self) -> Vec<UrlProperty> {
673		std::mem::take(&mut self.r#url)
674	}
675}
676#[cfg(feature = "serde")]
677mod serde {
678	use std::{fmt, fmt::Formatter};
679
680	use ::serde::{
681		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
682	};
683
684	use super::*;
685	impl Serialize for Place {
686		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
687		where
688			S: Serializer,
689		{
690			let len: usize = [
691				!Vec::is_empty(&self.r#additional_property) as usize,
692				!Vec::is_empty(&self.r#address) as usize,
693				!Vec::is_empty(&self.r#aggregate_rating) as usize,
694				!Vec::is_empty(&self.r#amenity_feature) as usize,
695				!Vec::is_empty(&self.r#branch_code) as usize,
696				!Vec::is_empty(&self.r#contained_in) as usize,
697				!Vec::is_empty(&self.r#contained_in_place) as usize,
698				!Vec::is_empty(&self.r#contains_place) as usize,
699				!Vec::is_empty(&self.r#event) as usize,
700				!Vec::is_empty(&self.r#events) as usize,
701				!Vec::is_empty(&self.r#fax_number) as usize,
702				!Vec::is_empty(&self.r#geo) as usize,
703				!Vec::is_empty(&self.r#geo_contains) as usize,
704				!Vec::is_empty(&self.r#geo_covered_by) as usize,
705				!Vec::is_empty(&self.r#geo_covers) as usize,
706				!Vec::is_empty(&self.r#geo_crosses) as usize,
707				!Vec::is_empty(&self.r#geo_disjoint) as usize,
708				!Vec::is_empty(&self.r#geo_equals) as usize,
709				!Vec::is_empty(&self.r#geo_intersects) as usize,
710				!Vec::is_empty(&self.r#geo_overlaps) as usize,
711				!Vec::is_empty(&self.r#geo_touches) as usize,
712				!Vec::is_empty(&self.r#geo_within) as usize,
713				!Vec::is_empty(&self.r#global_location_number) as usize,
714				!Vec::is_empty(&self.r#has_drive_through_service) as usize,
715				!Vec::is_empty(&self.r#has_map) as usize,
716				!Vec::is_empty(&self.r#is_accessible_for_free) as usize,
717				!Vec::is_empty(&self.r#isic_v_4) as usize,
718				!Vec::is_empty(&self.r#keywords) as usize,
719				!Vec::is_empty(&self.r#latitude) as usize,
720				!Vec::is_empty(&self.r#logo) as usize,
721				!Vec::is_empty(&self.r#longitude) as usize,
722				!Vec::is_empty(&self.r#map) as usize,
723				!Vec::is_empty(&self.r#maps) as usize,
724				!Vec::is_empty(&self.r#maximum_attendee_capacity) as usize,
725				!Vec::is_empty(&self.r#opening_hours_specification) as usize,
726				!Vec::is_empty(&self.r#photo) as usize,
727				!Vec::is_empty(&self.r#photos) as usize,
728				!Vec::is_empty(&self.r#public_access) as usize,
729				!Vec::is_empty(&self.r#review) as usize,
730				!Vec::is_empty(&self.r#reviews) as usize,
731				!Vec::is_empty(&self.r#slogan) as usize,
732				!Vec::is_empty(&self.r#smoking_allowed) as usize,
733				!Vec::is_empty(&self.r#special_opening_hours_specification) as usize,
734				!Vec::is_empty(&self.r#telephone) as usize,
735				!Vec::is_empty(&self.r#tour_booking_page) as usize,
736				!Vec::is_empty(&self.r#additional_type) as usize,
737				!Vec::is_empty(&self.r#alternate_name) as usize,
738				!Vec::is_empty(&self.r#description) as usize,
739				!Vec::is_empty(&self.r#disambiguating_description) as usize,
740				!Vec::is_empty(&self.r#identifier) as usize,
741				!Vec::is_empty(&self.r#image) as usize,
742				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
743				!Vec::is_empty(&self.r#name) as usize,
744				!Vec::is_empty(&self.r#potential_action) as usize,
745				!Vec::is_empty(&self.r#same_as) as usize,
746				!Vec::is_empty(&self.r#subject_of) as usize,
747				!Vec::is_empty(&self.r#url) as usize,
748			]
749			.iter()
750			.sum();
751			let mut serialize_struct = Serializer::serialize_struct(serializer, "Place", len)?;
752			if !Vec::is_empty(&self.r#additional_property) {
753				serialize_struct.serialize_field("additionalProperty", {
754					struct SerializeWith<'a>(&'a Vec<AdditionalPropertyProperty>);
755					impl<'a> Serialize for SerializeWith<'a> {
756						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
757						where
758							S: Serializer,
759						{
760							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
761								self.0, serializer,
762							)
763						}
764					}
765					&SerializeWith(&self.r#additional_property)
766				})?;
767			} else {
768				serialize_struct.skip_field("additionalProperty")?;
769			}
770			if !Vec::is_empty(&self.r#address) {
771				serialize_struct.serialize_field("address", {
772					struct SerializeWith<'a>(&'a Vec<AddressProperty>);
773					impl<'a> Serialize for SerializeWith<'a> {
774						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
775						where
776							S: Serializer,
777						{
778							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
779								self.0, serializer,
780							)
781						}
782					}
783					&SerializeWith(&self.r#address)
784				})?;
785			} else {
786				serialize_struct.skip_field("address")?;
787			}
788			if !Vec::is_empty(&self.r#aggregate_rating) {
789				serialize_struct.serialize_field("aggregateRating", {
790					struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
791					impl<'a> Serialize for SerializeWith<'a> {
792						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
793						where
794							S: Serializer,
795						{
796							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
797								self.0, serializer,
798							)
799						}
800					}
801					&SerializeWith(&self.r#aggregate_rating)
802				})?;
803			} else {
804				serialize_struct.skip_field("aggregateRating")?;
805			}
806			if !Vec::is_empty(&self.r#amenity_feature) {
807				serialize_struct.serialize_field("amenityFeature", {
808					struct SerializeWith<'a>(&'a Vec<AmenityFeatureProperty>);
809					impl<'a> Serialize for SerializeWith<'a> {
810						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
811						where
812							S: Serializer,
813						{
814							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
815								self.0, serializer,
816							)
817						}
818					}
819					&SerializeWith(&self.r#amenity_feature)
820				})?;
821			} else {
822				serialize_struct.skip_field("amenityFeature")?;
823			}
824			if !Vec::is_empty(&self.r#branch_code) {
825				serialize_struct.serialize_field("branchCode", {
826					struct SerializeWith<'a>(&'a Vec<BranchCodeProperty>);
827					impl<'a> Serialize for SerializeWith<'a> {
828						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
829						where
830							S: Serializer,
831						{
832							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
833								self.0, serializer,
834							)
835						}
836					}
837					&SerializeWith(&self.r#branch_code)
838				})?;
839			} else {
840				serialize_struct.skip_field("branchCode")?;
841			}
842			if !Vec::is_empty(&self.r#contained_in) {
843				serialize_struct.serialize_field("containedIn", {
844					struct SerializeWith<'a>(&'a Vec<ContainedInProperty>);
845					impl<'a> Serialize for SerializeWith<'a> {
846						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
847						where
848							S: Serializer,
849						{
850							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
851								self.0, serializer,
852							)
853						}
854					}
855					&SerializeWith(&self.r#contained_in)
856				})?;
857			} else {
858				serialize_struct.skip_field("containedIn")?;
859			}
860			if !Vec::is_empty(&self.r#contained_in_place) {
861				serialize_struct.serialize_field("containedInPlace", {
862					struct SerializeWith<'a>(&'a Vec<ContainedInPlaceProperty>);
863					impl<'a> Serialize for SerializeWith<'a> {
864						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
865						where
866							S: Serializer,
867						{
868							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
869								self.0, serializer,
870							)
871						}
872					}
873					&SerializeWith(&self.r#contained_in_place)
874				})?;
875			} else {
876				serialize_struct.skip_field("containedInPlace")?;
877			}
878			if !Vec::is_empty(&self.r#contains_place) {
879				serialize_struct.serialize_field("containsPlace", {
880					struct SerializeWith<'a>(&'a Vec<ContainsPlaceProperty>);
881					impl<'a> Serialize for SerializeWith<'a> {
882						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
883						where
884							S: Serializer,
885						{
886							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
887								self.0, serializer,
888							)
889						}
890					}
891					&SerializeWith(&self.r#contains_place)
892				})?;
893			} else {
894				serialize_struct.skip_field("containsPlace")?;
895			}
896			if !Vec::is_empty(&self.r#event) {
897				serialize_struct.serialize_field("event", {
898					struct SerializeWith<'a>(&'a Vec<EventProperty>);
899					impl<'a> Serialize for SerializeWith<'a> {
900						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
901						where
902							S: Serializer,
903						{
904							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
905								self.0, serializer,
906							)
907						}
908					}
909					&SerializeWith(&self.r#event)
910				})?;
911			} else {
912				serialize_struct.skip_field("event")?;
913			}
914			if !Vec::is_empty(&self.r#events) {
915				serialize_struct.serialize_field("events", {
916					struct SerializeWith<'a>(&'a Vec<EventsProperty>);
917					impl<'a> Serialize for SerializeWith<'a> {
918						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
919						where
920							S: Serializer,
921						{
922							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
923								self.0, serializer,
924							)
925						}
926					}
927					&SerializeWith(&self.r#events)
928				})?;
929			} else {
930				serialize_struct.skip_field("events")?;
931			}
932			if !Vec::is_empty(&self.r#fax_number) {
933				serialize_struct.serialize_field("faxNumber", {
934					struct SerializeWith<'a>(&'a Vec<FaxNumberProperty>);
935					impl<'a> Serialize for SerializeWith<'a> {
936						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
937						where
938							S: Serializer,
939						{
940							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
941								self.0, serializer,
942							)
943						}
944					}
945					&SerializeWith(&self.r#fax_number)
946				})?;
947			} else {
948				serialize_struct.skip_field("faxNumber")?;
949			}
950			if !Vec::is_empty(&self.r#geo) {
951				serialize_struct.serialize_field("geo", {
952					struct SerializeWith<'a>(&'a Vec<GeoProperty>);
953					impl<'a> Serialize for SerializeWith<'a> {
954						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
955						where
956							S: Serializer,
957						{
958							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
959								self.0, serializer,
960							)
961						}
962					}
963					&SerializeWith(&self.r#geo)
964				})?;
965			} else {
966				serialize_struct.skip_field("geo")?;
967			}
968			if !Vec::is_empty(&self.r#geo_contains) {
969				serialize_struct.serialize_field("geoContains", {
970					struct SerializeWith<'a>(&'a Vec<GeoContainsProperty>);
971					impl<'a> Serialize for SerializeWith<'a> {
972						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
973						where
974							S: Serializer,
975						{
976							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
977								self.0, serializer,
978							)
979						}
980					}
981					&SerializeWith(&self.r#geo_contains)
982				})?;
983			} else {
984				serialize_struct.skip_field("geoContains")?;
985			}
986			if !Vec::is_empty(&self.r#geo_covered_by) {
987				serialize_struct.serialize_field("geoCoveredBy", {
988					struct SerializeWith<'a>(&'a Vec<GeoCoveredByProperty>);
989					impl<'a> Serialize for SerializeWith<'a> {
990						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
991						where
992							S: Serializer,
993						{
994							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
995								self.0, serializer,
996							)
997						}
998					}
999					&SerializeWith(&self.r#geo_covered_by)
1000				})?;
1001			} else {
1002				serialize_struct.skip_field("geoCoveredBy")?;
1003			}
1004			if !Vec::is_empty(&self.r#geo_covers) {
1005				serialize_struct.serialize_field("geoCovers", {
1006					struct SerializeWith<'a>(&'a Vec<GeoCoversProperty>);
1007					impl<'a> Serialize for SerializeWith<'a> {
1008						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1009						where
1010							S: Serializer,
1011						{
1012							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1013								self.0, serializer,
1014							)
1015						}
1016					}
1017					&SerializeWith(&self.r#geo_covers)
1018				})?;
1019			} else {
1020				serialize_struct.skip_field("geoCovers")?;
1021			}
1022			if !Vec::is_empty(&self.r#geo_crosses) {
1023				serialize_struct.serialize_field("geoCrosses", {
1024					struct SerializeWith<'a>(&'a Vec<GeoCrossesProperty>);
1025					impl<'a> Serialize for SerializeWith<'a> {
1026						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1027						where
1028							S: Serializer,
1029						{
1030							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1031								self.0, serializer,
1032							)
1033						}
1034					}
1035					&SerializeWith(&self.r#geo_crosses)
1036				})?;
1037			} else {
1038				serialize_struct.skip_field("geoCrosses")?;
1039			}
1040			if !Vec::is_empty(&self.r#geo_disjoint) {
1041				serialize_struct.serialize_field("geoDisjoint", {
1042					struct SerializeWith<'a>(&'a Vec<GeoDisjointProperty>);
1043					impl<'a> Serialize for SerializeWith<'a> {
1044						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1045						where
1046							S: Serializer,
1047						{
1048							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1049								self.0, serializer,
1050							)
1051						}
1052					}
1053					&SerializeWith(&self.r#geo_disjoint)
1054				})?;
1055			} else {
1056				serialize_struct.skip_field("geoDisjoint")?;
1057			}
1058			if !Vec::is_empty(&self.r#geo_equals) {
1059				serialize_struct.serialize_field("geoEquals", {
1060					struct SerializeWith<'a>(&'a Vec<GeoEqualsProperty>);
1061					impl<'a> Serialize for SerializeWith<'a> {
1062						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1063						where
1064							S: Serializer,
1065						{
1066							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1067								self.0, serializer,
1068							)
1069						}
1070					}
1071					&SerializeWith(&self.r#geo_equals)
1072				})?;
1073			} else {
1074				serialize_struct.skip_field("geoEquals")?;
1075			}
1076			if !Vec::is_empty(&self.r#geo_intersects) {
1077				serialize_struct.serialize_field("geoIntersects", {
1078					struct SerializeWith<'a>(&'a Vec<GeoIntersectsProperty>);
1079					impl<'a> Serialize for SerializeWith<'a> {
1080						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1081						where
1082							S: Serializer,
1083						{
1084							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1085								self.0, serializer,
1086							)
1087						}
1088					}
1089					&SerializeWith(&self.r#geo_intersects)
1090				})?;
1091			} else {
1092				serialize_struct.skip_field("geoIntersects")?;
1093			}
1094			if !Vec::is_empty(&self.r#geo_overlaps) {
1095				serialize_struct.serialize_field("geoOverlaps", {
1096					struct SerializeWith<'a>(&'a Vec<GeoOverlapsProperty>);
1097					impl<'a> Serialize for SerializeWith<'a> {
1098						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1099						where
1100							S: Serializer,
1101						{
1102							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1103								self.0, serializer,
1104							)
1105						}
1106					}
1107					&SerializeWith(&self.r#geo_overlaps)
1108				})?;
1109			} else {
1110				serialize_struct.skip_field("geoOverlaps")?;
1111			}
1112			if !Vec::is_empty(&self.r#geo_touches) {
1113				serialize_struct.serialize_field("geoTouches", {
1114					struct SerializeWith<'a>(&'a Vec<GeoTouchesProperty>);
1115					impl<'a> Serialize for SerializeWith<'a> {
1116						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1117						where
1118							S: Serializer,
1119						{
1120							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1121								self.0, serializer,
1122							)
1123						}
1124					}
1125					&SerializeWith(&self.r#geo_touches)
1126				})?;
1127			} else {
1128				serialize_struct.skip_field("geoTouches")?;
1129			}
1130			if !Vec::is_empty(&self.r#geo_within) {
1131				serialize_struct.serialize_field("geoWithin", {
1132					struct SerializeWith<'a>(&'a Vec<GeoWithinProperty>);
1133					impl<'a> Serialize for SerializeWith<'a> {
1134						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1135						where
1136							S: Serializer,
1137						{
1138							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1139								self.0, serializer,
1140							)
1141						}
1142					}
1143					&SerializeWith(&self.r#geo_within)
1144				})?;
1145			} else {
1146				serialize_struct.skip_field("geoWithin")?;
1147			}
1148			if !Vec::is_empty(&self.r#global_location_number) {
1149				serialize_struct.serialize_field("globalLocationNumber", {
1150					struct SerializeWith<'a>(&'a Vec<GlobalLocationNumberProperty>);
1151					impl<'a> Serialize for SerializeWith<'a> {
1152						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1153						where
1154							S: Serializer,
1155						{
1156							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1157								self.0, serializer,
1158							)
1159						}
1160					}
1161					&SerializeWith(&self.r#global_location_number)
1162				})?;
1163			} else {
1164				serialize_struct.skip_field("globalLocationNumber")?;
1165			}
1166			if !Vec::is_empty(&self.r#has_drive_through_service) {
1167				serialize_struct.serialize_field("hasDriveThroughService", {
1168					struct SerializeWith<'a>(&'a Vec<HasDriveThroughServiceProperty>);
1169					impl<'a> Serialize for SerializeWith<'a> {
1170						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1171						where
1172							S: Serializer,
1173						{
1174							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1175								self.0, serializer,
1176							)
1177						}
1178					}
1179					&SerializeWith(&self.r#has_drive_through_service)
1180				})?;
1181			} else {
1182				serialize_struct.skip_field("hasDriveThroughService")?;
1183			}
1184			if !Vec::is_empty(&self.r#has_map) {
1185				serialize_struct.serialize_field("hasMap", {
1186					struct SerializeWith<'a>(&'a Vec<HasMapProperty>);
1187					impl<'a> Serialize for SerializeWith<'a> {
1188						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1189						where
1190							S: Serializer,
1191						{
1192							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1193								self.0, serializer,
1194							)
1195						}
1196					}
1197					&SerializeWith(&self.r#has_map)
1198				})?;
1199			} else {
1200				serialize_struct.skip_field("hasMap")?;
1201			}
1202			if !Vec::is_empty(&self.r#is_accessible_for_free) {
1203				serialize_struct.serialize_field("isAccessibleForFree", {
1204					struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
1205					impl<'a> Serialize for SerializeWith<'a> {
1206						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1207						where
1208							S: Serializer,
1209						{
1210							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1211								self.0, serializer,
1212							)
1213						}
1214					}
1215					&SerializeWith(&self.r#is_accessible_for_free)
1216				})?;
1217			} else {
1218				serialize_struct.skip_field("isAccessibleForFree")?;
1219			}
1220			if !Vec::is_empty(&self.r#isic_v_4) {
1221				serialize_struct.serialize_field("isicV4", {
1222					struct SerializeWith<'a>(&'a Vec<IsicV4Property>);
1223					impl<'a> Serialize for SerializeWith<'a> {
1224						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1225						where
1226							S: Serializer,
1227						{
1228							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1229								self.0, serializer,
1230							)
1231						}
1232					}
1233					&SerializeWith(&self.r#isic_v_4)
1234				})?;
1235			} else {
1236				serialize_struct.skip_field("isicV4")?;
1237			}
1238			if !Vec::is_empty(&self.r#keywords) {
1239				serialize_struct.serialize_field("keywords", {
1240					struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
1241					impl<'a> Serialize for SerializeWith<'a> {
1242						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1243						where
1244							S: Serializer,
1245						{
1246							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1247								self.0, serializer,
1248							)
1249						}
1250					}
1251					&SerializeWith(&self.r#keywords)
1252				})?;
1253			} else {
1254				serialize_struct.skip_field("keywords")?;
1255			}
1256			if !Vec::is_empty(&self.r#latitude) {
1257				serialize_struct.serialize_field("latitude", {
1258					struct SerializeWith<'a>(&'a Vec<LatitudeProperty>);
1259					impl<'a> Serialize for SerializeWith<'a> {
1260						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1261						where
1262							S: Serializer,
1263						{
1264							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1265								self.0, serializer,
1266							)
1267						}
1268					}
1269					&SerializeWith(&self.r#latitude)
1270				})?;
1271			} else {
1272				serialize_struct.skip_field("latitude")?;
1273			}
1274			if !Vec::is_empty(&self.r#logo) {
1275				serialize_struct.serialize_field("logo", {
1276					struct SerializeWith<'a>(&'a Vec<LogoProperty>);
1277					impl<'a> Serialize for SerializeWith<'a> {
1278						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1279						where
1280							S: Serializer,
1281						{
1282							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1283								self.0, serializer,
1284							)
1285						}
1286					}
1287					&SerializeWith(&self.r#logo)
1288				})?;
1289			} else {
1290				serialize_struct.skip_field("logo")?;
1291			}
1292			if !Vec::is_empty(&self.r#longitude) {
1293				serialize_struct.serialize_field("longitude", {
1294					struct SerializeWith<'a>(&'a Vec<LongitudeProperty>);
1295					impl<'a> Serialize for SerializeWith<'a> {
1296						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1297						where
1298							S: Serializer,
1299						{
1300							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1301								self.0, serializer,
1302							)
1303						}
1304					}
1305					&SerializeWith(&self.r#longitude)
1306				})?;
1307			} else {
1308				serialize_struct.skip_field("longitude")?;
1309			}
1310			if !Vec::is_empty(&self.r#map) {
1311				serialize_struct.serialize_field("map", {
1312					struct SerializeWith<'a>(&'a Vec<MapProperty>);
1313					impl<'a> Serialize for SerializeWith<'a> {
1314						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1315						where
1316							S: Serializer,
1317						{
1318							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1319								self.0, serializer,
1320							)
1321						}
1322					}
1323					&SerializeWith(&self.r#map)
1324				})?;
1325			} else {
1326				serialize_struct.skip_field("map")?;
1327			}
1328			if !Vec::is_empty(&self.r#maps) {
1329				serialize_struct.serialize_field("maps", {
1330					struct SerializeWith<'a>(&'a Vec<MapsProperty>);
1331					impl<'a> Serialize for SerializeWith<'a> {
1332						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1333						where
1334							S: Serializer,
1335						{
1336							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1337								self.0, serializer,
1338							)
1339						}
1340					}
1341					&SerializeWith(&self.r#maps)
1342				})?;
1343			} else {
1344				serialize_struct.skip_field("maps")?;
1345			}
1346			if !Vec::is_empty(&self.r#maximum_attendee_capacity) {
1347				serialize_struct.serialize_field("maximumAttendeeCapacity", {
1348					struct SerializeWith<'a>(&'a Vec<MaximumAttendeeCapacityProperty>);
1349					impl<'a> Serialize for SerializeWith<'a> {
1350						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1351						where
1352							S: Serializer,
1353						{
1354							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1355								self.0, serializer,
1356							)
1357						}
1358					}
1359					&SerializeWith(&self.r#maximum_attendee_capacity)
1360				})?;
1361			} else {
1362				serialize_struct.skip_field("maximumAttendeeCapacity")?;
1363			}
1364			if !Vec::is_empty(&self.r#opening_hours_specification) {
1365				serialize_struct.serialize_field("openingHoursSpecification", {
1366					struct SerializeWith<'a>(&'a Vec<OpeningHoursSpecificationProperty>);
1367					impl<'a> Serialize for SerializeWith<'a> {
1368						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1369						where
1370							S: Serializer,
1371						{
1372							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1373								self.0, serializer,
1374							)
1375						}
1376					}
1377					&SerializeWith(&self.r#opening_hours_specification)
1378				})?;
1379			} else {
1380				serialize_struct.skip_field("openingHoursSpecification")?;
1381			}
1382			if !Vec::is_empty(&self.r#photo) {
1383				serialize_struct.serialize_field("photo", {
1384					struct SerializeWith<'a>(&'a Vec<PhotoProperty>);
1385					impl<'a> Serialize for SerializeWith<'a> {
1386						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1387						where
1388							S: Serializer,
1389						{
1390							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1391								self.0, serializer,
1392							)
1393						}
1394					}
1395					&SerializeWith(&self.r#photo)
1396				})?;
1397			} else {
1398				serialize_struct.skip_field("photo")?;
1399			}
1400			if !Vec::is_empty(&self.r#photos) {
1401				serialize_struct.serialize_field("photos", {
1402					struct SerializeWith<'a>(&'a Vec<PhotosProperty>);
1403					impl<'a> Serialize for SerializeWith<'a> {
1404						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1405						where
1406							S: Serializer,
1407						{
1408							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1409								self.0, serializer,
1410							)
1411						}
1412					}
1413					&SerializeWith(&self.r#photos)
1414				})?;
1415			} else {
1416				serialize_struct.skip_field("photos")?;
1417			}
1418			if !Vec::is_empty(&self.r#public_access) {
1419				serialize_struct.serialize_field("publicAccess", {
1420					struct SerializeWith<'a>(&'a Vec<PublicAccessProperty>);
1421					impl<'a> Serialize for SerializeWith<'a> {
1422						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1423						where
1424							S: Serializer,
1425						{
1426							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1427								self.0, serializer,
1428							)
1429						}
1430					}
1431					&SerializeWith(&self.r#public_access)
1432				})?;
1433			} else {
1434				serialize_struct.skip_field("publicAccess")?;
1435			}
1436			if !Vec::is_empty(&self.r#review) {
1437				serialize_struct.serialize_field("review", {
1438					struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
1439					impl<'a> Serialize for SerializeWith<'a> {
1440						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1441						where
1442							S: Serializer,
1443						{
1444							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1445								self.0, serializer,
1446							)
1447						}
1448					}
1449					&SerializeWith(&self.r#review)
1450				})?;
1451			} else {
1452				serialize_struct.skip_field("review")?;
1453			}
1454			if !Vec::is_empty(&self.r#reviews) {
1455				serialize_struct.serialize_field("reviews", {
1456					struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
1457					impl<'a> Serialize for SerializeWith<'a> {
1458						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1459						where
1460							S: Serializer,
1461						{
1462							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1463								self.0, serializer,
1464							)
1465						}
1466					}
1467					&SerializeWith(&self.r#reviews)
1468				})?;
1469			} else {
1470				serialize_struct.skip_field("reviews")?;
1471			}
1472			if !Vec::is_empty(&self.r#slogan) {
1473				serialize_struct.serialize_field("slogan", {
1474					struct SerializeWith<'a>(&'a Vec<SloganProperty>);
1475					impl<'a> Serialize for SerializeWith<'a> {
1476						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1477						where
1478							S: Serializer,
1479						{
1480							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1481								self.0, serializer,
1482							)
1483						}
1484					}
1485					&SerializeWith(&self.r#slogan)
1486				})?;
1487			} else {
1488				serialize_struct.skip_field("slogan")?;
1489			}
1490			if !Vec::is_empty(&self.r#smoking_allowed) {
1491				serialize_struct.serialize_field("smokingAllowed", {
1492					struct SerializeWith<'a>(&'a Vec<SmokingAllowedProperty>);
1493					impl<'a> Serialize for SerializeWith<'a> {
1494						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1495						where
1496							S: Serializer,
1497						{
1498							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1499								self.0, serializer,
1500							)
1501						}
1502					}
1503					&SerializeWith(&self.r#smoking_allowed)
1504				})?;
1505			} else {
1506				serialize_struct.skip_field("smokingAllowed")?;
1507			}
1508			if !Vec::is_empty(&self.r#special_opening_hours_specification) {
1509				serialize_struct.serialize_field("specialOpeningHoursSpecification", {
1510					struct SerializeWith<'a>(&'a Vec<SpecialOpeningHoursSpecificationProperty>);
1511					impl<'a> Serialize for SerializeWith<'a> {
1512						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1513						where
1514							S: Serializer,
1515						{
1516							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1517								self.0, serializer,
1518							)
1519						}
1520					}
1521					&SerializeWith(&self.r#special_opening_hours_specification)
1522				})?;
1523			} else {
1524				serialize_struct.skip_field("specialOpeningHoursSpecification")?;
1525			}
1526			if !Vec::is_empty(&self.r#telephone) {
1527				serialize_struct.serialize_field("telephone", {
1528					struct SerializeWith<'a>(&'a Vec<TelephoneProperty>);
1529					impl<'a> Serialize for SerializeWith<'a> {
1530						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1531						where
1532							S: Serializer,
1533						{
1534							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1535								self.0, serializer,
1536							)
1537						}
1538					}
1539					&SerializeWith(&self.r#telephone)
1540				})?;
1541			} else {
1542				serialize_struct.skip_field("telephone")?;
1543			}
1544			if !Vec::is_empty(&self.r#tour_booking_page) {
1545				serialize_struct.serialize_field("tourBookingPage", {
1546					struct SerializeWith<'a>(&'a Vec<TourBookingPageProperty>);
1547					impl<'a> Serialize for SerializeWith<'a> {
1548						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1549						where
1550							S: Serializer,
1551						{
1552							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1553								self.0, serializer,
1554							)
1555						}
1556					}
1557					&SerializeWith(&self.r#tour_booking_page)
1558				})?;
1559			} else {
1560				serialize_struct.skip_field("tourBookingPage")?;
1561			}
1562			if !Vec::is_empty(&self.r#additional_type) {
1563				serialize_struct.serialize_field("additionalType", {
1564					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
1565					impl<'a> Serialize for SerializeWith<'a> {
1566						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1567						where
1568							S: Serializer,
1569						{
1570							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1571								self.0, serializer,
1572							)
1573						}
1574					}
1575					&SerializeWith(&self.r#additional_type)
1576				})?;
1577			} else {
1578				serialize_struct.skip_field("additionalType")?;
1579			}
1580			if !Vec::is_empty(&self.r#alternate_name) {
1581				serialize_struct.serialize_field("alternateName", {
1582					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
1583					impl<'a> Serialize for SerializeWith<'a> {
1584						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1585						where
1586							S: Serializer,
1587						{
1588							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1589								self.0, serializer,
1590							)
1591						}
1592					}
1593					&SerializeWith(&self.r#alternate_name)
1594				})?;
1595			} else {
1596				serialize_struct.skip_field("alternateName")?;
1597			}
1598			if !Vec::is_empty(&self.r#description) {
1599				serialize_struct.serialize_field("description", {
1600					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
1601					impl<'a> Serialize for SerializeWith<'a> {
1602						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1603						where
1604							S: Serializer,
1605						{
1606							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1607								self.0, serializer,
1608							)
1609						}
1610					}
1611					&SerializeWith(&self.r#description)
1612				})?;
1613			} else {
1614				serialize_struct.skip_field("description")?;
1615			}
1616			if !Vec::is_empty(&self.r#disambiguating_description) {
1617				serialize_struct.serialize_field("disambiguatingDescription", {
1618					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
1619					impl<'a> Serialize for SerializeWith<'a> {
1620						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1621						where
1622							S: Serializer,
1623						{
1624							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1625								self.0, serializer,
1626							)
1627						}
1628					}
1629					&SerializeWith(&self.r#disambiguating_description)
1630				})?;
1631			} else {
1632				serialize_struct.skip_field("disambiguatingDescription")?;
1633			}
1634			if !Vec::is_empty(&self.r#identifier) {
1635				serialize_struct.serialize_field("identifier", {
1636					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
1637					impl<'a> Serialize for SerializeWith<'a> {
1638						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1639						where
1640							S: Serializer,
1641						{
1642							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1643								self.0, serializer,
1644							)
1645						}
1646					}
1647					&SerializeWith(&self.r#identifier)
1648				})?;
1649			} else {
1650				serialize_struct.skip_field("identifier")?;
1651			}
1652			if !Vec::is_empty(&self.r#image) {
1653				serialize_struct.serialize_field("image", {
1654					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
1655					impl<'a> Serialize for SerializeWith<'a> {
1656						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1657						where
1658							S: Serializer,
1659						{
1660							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1661								self.0, serializer,
1662							)
1663						}
1664					}
1665					&SerializeWith(&self.r#image)
1666				})?;
1667			} else {
1668				serialize_struct.skip_field("image")?;
1669			}
1670			if !Vec::is_empty(&self.r#main_entity_of_page) {
1671				serialize_struct.serialize_field("mainEntityOfPage", {
1672					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
1673					impl<'a> Serialize for SerializeWith<'a> {
1674						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1675						where
1676							S: Serializer,
1677						{
1678							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1679								self.0, serializer,
1680							)
1681						}
1682					}
1683					&SerializeWith(&self.r#main_entity_of_page)
1684				})?;
1685			} else {
1686				serialize_struct.skip_field("mainEntityOfPage")?;
1687			}
1688			if !Vec::is_empty(&self.r#name) {
1689				serialize_struct.serialize_field("name", {
1690					struct SerializeWith<'a>(&'a Vec<NameProperty>);
1691					impl<'a> Serialize for SerializeWith<'a> {
1692						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1693						where
1694							S: Serializer,
1695						{
1696							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1697								self.0, serializer,
1698							)
1699						}
1700					}
1701					&SerializeWith(&self.r#name)
1702				})?;
1703			} else {
1704				serialize_struct.skip_field("name")?;
1705			}
1706			if !Vec::is_empty(&self.r#potential_action) {
1707				serialize_struct.serialize_field("potentialAction", {
1708					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
1709					impl<'a> Serialize for SerializeWith<'a> {
1710						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1711						where
1712							S: Serializer,
1713						{
1714							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1715								self.0, serializer,
1716							)
1717						}
1718					}
1719					&SerializeWith(&self.r#potential_action)
1720				})?;
1721			} else {
1722				serialize_struct.skip_field("potentialAction")?;
1723			}
1724			if !Vec::is_empty(&self.r#same_as) {
1725				serialize_struct.serialize_field("sameAs", {
1726					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
1727					impl<'a> Serialize for SerializeWith<'a> {
1728						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1729						where
1730							S: Serializer,
1731						{
1732							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1733								self.0, serializer,
1734							)
1735						}
1736					}
1737					&SerializeWith(&self.r#same_as)
1738				})?;
1739			} else {
1740				serialize_struct.skip_field("sameAs")?;
1741			}
1742			if !Vec::is_empty(&self.r#subject_of) {
1743				serialize_struct.serialize_field("subjectOf", {
1744					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
1745					impl<'a> Serialize for SerializeWith<'a> {
1746						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1747						where
1748							S: Serializer,
1749						{
1750							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1751								self.0, serializer,
1752							)
1753						}
1754					}
1755					&SerializeWith(&self.r#subject_of)
1756				})?;
1757			} else {
1758				serialize_struct.skip_field("subjectOf")?;
1759			}
1760			if !Vec::is_empty(&self.r#url) {
1761				serialize_struct.serialize_field("url", {
1762					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
1763					impl<'a> Serialize for SerializeWith<'a> {
1764						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1765						where
1766							S: Serializer,
1767						{
1768							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1769								self.0, serializer,
1770							)
1771						}
1772					}
1773					&SerializeWith(&self.r#url)
1774				})?;
1775			} else {
1776				serialize_struct.skip_field("url")?;
1777			}
1778			serialize_struct.end()
1779		}
1780	}
1781	impl<'de> Deserialize<'de> for Place {
1782		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1783		where
1784			D: Deserializer<'de>,
1785		{
1786			enum Field {
1787				AdditionalProperty,
1788				Address,
1789				AggregateRating,
1790				AmenityFeature,
1791				BranchCode,
1792				ContainedIn,
1793				ContainedInPlace,
1794				ContainsPlace,
1795				Event,
1796				Events,
1797				FaxNumber,
1798				Geo,
1799				GeoContains,
1800				GeoCoveredBy,
1801				GeoCovers,
1802				GeoCrosses,
1803				GeoDisjoint,
1804				GeoEquals,
1805				GeoIntersects,
1806				GeoOverlaps,
1807				GeoTouches,
1808				GeoWithin,
1809				GlobalLocationNumber,
1810				HasDriveThroughService,
1811				HasMap,
1812				IsAccessibleForFree,
1813				IsicV4,
1814				Keywords,
1815				Latitude,
1816				Logo,
1817				Longitude,
1818				Map,
1819				Maps,
1820				MaximumAttendeeCapacity,
1821				OpeningHoursSpecification,
1822				Photo,
1823				Photos,
1824				PublicAccess,
1825				Review,
1826				Reviews,
1827				Slogan,
1828				SmokingAllowed,
1829				SpecialOpeningHoursSpecification,
1830				Telephone,
1831				TourBookingPage,
1832				AdditionalType,
1833				AlternateName,
1834				Description,
1835				DisambiguatingDescription,
1836				Identifier,
1837				Image,
1838				MainEntityOfPage,
1839				Name,
1840				PotentialAction,
1841				SameAs,
1842				SubjectOf,
1843				Url,
1844				Ignore,
1845			}
1846			struct FieldVisitor;
1847			impl<'de> Visitor<'de> for FieldVisitor {
1848				type Value = Field;
1849				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1850					formatter.write_str("field identifier")
1851				}
1852				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1853				where
1854					E: de::Error,
1855				{
1856					match value {
1857						"additionalProperty" => Ok(Field::AdditionalProperty),
1858						"address" => Ok(Field::Address),
1859						"aggregateRating" => Ok(Field::AggregateRating),
1860						"amenityFeature" => Ok(Field::AmenityFeature),
1861						"branchCode" => Ok(Field::BranchCode),
1862						"containedIn" => Ok(Field::ContainedIn),
1863						"containedInPlace" => Ok(Field::ContainedInPlace),
1864						"containsPlace" => Ok(Field::ContainsPlace),
1865						"event" => Ok(Field::Event),
1866						"events" => Ok(Field::Events),
1867						"faxNumber" => Ok(Field::FaxNumber),
1868						"geo" => Ok(Field::Geo),
1869						"geoContains" => Ok(Field::GeoContains),
1870						"geoCoveredBy" => Ok(Field::GeoCoveredBy),
1871						"geoCovers" => Ok(Field::GeoCovers),
1872						"geoCrosses" => Ok(Field::GeoCrosses),
1873						"geoDisjoint" => Ok(Field::GeoDisjoint),
1874						"geoEquals" => Ok(Field::GeoEquals),
1875						"geoIntersects" => Ok(Field::GeoIntersects),
1876						"geoOverlaps" => Ok(Field::GeoOverlaps),
1877						"geoTouches" => Ok(Field::GeoTouches),
1878						"geoWithin" => Ok(Field::GeoWithin),
1879						"globalLocationNumber" => Ok(Field::GlobalLocationNumber),
1880						"hasDriveThroughService" => Ok(Field::HasDriveThroughService),
1881						"hasMap" => Ok(Field::HasMap),
1882						"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
1883						"isicV4" => Ok(Field::IsicV4),
1884						"keywords" => Ok(Field::Keywords),
1885						"latitude" => Ok(Field::Latitude),
1886						"logo" => Ok(Field::Logo),
1887						"longitude" => Ok(Field::Longitude),
1888						"map" => Ok(Field::Map),
1889						"maps" => Ok(Field::Maps),
1890						"maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
1891						"openingHoursSpecification" => Ok(Field::OpeningHoursSpecification),
1892						"photo" => Ok(Field::Photo),
1893						"photos" => Ok(Field::Photos),
1894						"publicAccess" => Ok(Field::PublicAccess),
1895						"review" => Ok(Field::Review),
1896						"reviews" => Ok(Field::Reviews),
1897						"slogan" => Ok(Field::Slogan),
1898						"smokingAllowed" => Ok(Field::SmokingAllowed),
1899						"specialOpeningHoursSpecification" => {
1900							Ok(Field::SpecialOpeningHoursSpecification)
1901						}
1902						"telephone" => Ok(Field::Telephone),
1903						"tourBookingPage" => Ok(Field::TourBookingPage),
1904						"additionalType" => Ok(Field::AdditionalType),
1905						"alternateName" => Ok(Field::AlternateName),
1906						"description" => Ok(Field::Description),
1907						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1908						"identifier" => Ok(Field::Identifier),
1909						"image" => Ok(Field::Image),
1910						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1911						"name" => Ok(Field::Name),
1912						"potentialAction" => Ok(Field::PotentialAction),
1913						"sameAs" => Ok(Field::SameAs),
1914						"subjectOf" => Ok(Field::SubjectOf),
1915						"url" => Ok(Field::Url),
1916						"id" | "type" => Ok(Field::Ignore),
1917						_ => Err(de::Error::unknown_field(value, FIELDS)),
1918					}
1919				}
1920				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1921				where
1922					E: de::Error,
1923				{
1924					match value {
1925						b"additionalProperty" => Ok(Field::AdditionalProperty),
1926						b"address" => Ok(Field::Address),
1927						b"aggregateRating" => Ok(Field::AggregateRating),
1928						b"amenityFeature" => Ok(Field::AmenityFeature),
1929						b"branchCode" => Ok(Field::BranchCode),
1930						b"containedIn" => Ok(Field::ContainedIn),
1931						b"containedInPlace" => Ok(Field::ContainedInPlace),
1932						b"containsPlace" => Ok(Field::ContainsPlace),
1933						b"event" => Ok(Field::Event),
1934						b"events" => Ok(Field::Events),
1935						b"faxNumber" => Ok(Field::FaxNumber),
1936						b"geo" => Ok(Field::Geo),
1937						b"geoContains" => Ok(Field::GeoContains),
1938						b"geoCoveredBy" => Ok(Field::GeoCoveredBy),
1939						b"geoCovers" => Ok(Field::GeoCovers),
1940						b"geoCrosses" => Ok(Field::GeoCrosses),
1941						b"geoDisjoint" => Ok(Field::GeoDisjoint),
1942						b"geoEquals" => Ok(Field::GeoEquals),
1943						b"geoIntersects" => Ok(Field::GeoIntersects),
1944						b"geoOverlaps" => Ok(Field::GeoOverlaps),
1945						b"geoTouches" => Ok(Field::GeoTouches),
1946						b"geoWithin" => Ok(Field::GeoWithin),
1947						b"globalLocationNumber" => Ok(Field::GlobalLocationNumber),
1948						b"hasDriveThroughService" => Ok(Field::HasDriveThroughService),
1949						b"hasMap" => Ok(Field::HasMap),
1950						b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
1951						b"isicV4" => Ok(Field::IsicV4),
1952						b"keywords" => Ok(Field::Keywords),
1953						b"latitude" => Ok(Field::Latitude),
1954						b"logo" => Ok(Field::Logo),
1955						b"longitude" => Ok(Field::Longitude),
1956						b"map" => Ok(Field::Map),
1957						b"maps" => Ok(Field::Maps),
1958						b"maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
1959						b"openingHoursSpecification" => Ok(Field::OpeningHoursSpecification),
1960						b"photo" => Ok(Field::Photo),
1961						b"photos" => Ok(Field::Photos),
1962						b"publicAccess" => Ok(Field::PublicAccess),
1963						b"review" => Ok(Field::Review),
1964						b"reviews" => Ok(Field::Reviews),
1965						b"slogan" => Ok(Field::Slogan),
1966						b"smokingAllowed" => Ok(Field::SmokingAllowed),
1967						b"specialOpeningHoursSpecification" => {
1968							Ok(Field::SpecialOpeningHoursSpecification)
1969						}
1970						b"telephone" => Ok(Field::Telephone),
1971						b"tourBookingPage" => Ok(Field::TourBookingPage),
1972						b"additionalType" => Ok(Field::AdditionalType),
1973						b"alternateName" => Ok(Field::AlternateName),
1974						b"description" => Ok(Field::Description),
1975						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1976						b"identifier" => Ok(Field::Identifier),
1977						b"image" => Ok(Field::Image),
1978						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1979						b"name" => Ok(Field::Name),
1980						b"potentialAction" => Ok(Field::PotentialAction),
1981						b"sameAs" => Ok(Field::SameAs),
1982						b"subjectOf" => Ok(Field::SubjectOf),
1983						b"url" => Ok(Field::Url),
1984						b"id" | b"type" => Ok(Field::Ignore),
1985						_ => {
1986							let value = &String::from_utf8_lossy(value);
1987							Err(de::Error::unknown_field(value, FIELDS))
1988						}
1989					}
1990				}
1991			}
1992			impl<'de> Deserialize<'de> for Field {
1993				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1994				where
1995					D: Deserializer<'de>,
1996				{
1997					deserializer.deserialize_identifier(FieldVisitor)
1998				}
1999			}
2000			struct ClassVisitor;
2001			impl<'de> Visitor<'de> for ClassVisitor {
2002				type Value = Place;
2003				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
2004					formatter.write_str("schema.org schema Place")
2005				}
2006				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2007				where
2008					A: de::MapAccess<'de>,
2009				{
2010					let mut r#additional_property_property = None;
2011					let mut r#address_property = None;
2012					let mut r#aggregate_rating_property = None;
2013					let mut r#amenity_feature_property = None;
2014					let mut r#branch_code_property = None;
2015					let mut r#contained_in_property = None;
2016					let mut r#contained_in_place_property = None;
2017					let mut r#contains_place_property = None;
2018					let mut r#event_property = None;
2019					let mut r#events_property = None;
2020					let mut r#fax_number_property = None;
2021					let mut r#geo_property = None;
2022					let mut r#geo_contains_property = None;
2023					let mut r#geo_covered_by_property = None;
2024					let mut r#geo_covers_property = None;
2025					let mut r#geo_crosses_property = None;
2026					let mut r#geo_disjoint_property = None;
2027					let mut r#geo_equals_property = None;
2028					let mut r#geo_intersects_property = None;
2029					let mut r#geo_overlaps_property = None;
2030					let mut r#geo_touches_property = None;
2031					let mut r#geo_within_property = None;
2032					let mut r#global_location_number_property = None;
2033					let mut r#has_drive_through_service_property = None;
2034					let mut r#has_map_property = None;
2035					let mut r#is_accessible_for_free_property = None;
2036					let mut r#isic_v_4_property = None;
2037					let mut r#keywords_property = None;
2038					let mut r#latitude_property = None;
2039					let mut r#logo_property = None;
2040					let mut r#longitude_property = None;
2041					let mut r#map_property = None;
2042					let mut r#maps_property = None;
2043					let mut r#maximum_attendee_capacity_property = None;
2044					let mut r#opening_hours_specification_property = None;
2045					let mut r#photo_property = None;
2046					let mut r#photos_property = None;
2047					let mut r#public_access_property = None;
2048					let mut r#review_property = None;
2049					let mut r#reviews_property = None;
2050					let mut r#slogan_property = None;
2051					let mut r#smoking_allowed_property = None;
2052					let mut r#special_opening_hours_specification_property = None;
2053					let mut r#telephone_property = None;
2054					let mut r#tour_booking_page_property = None;
2055					let mut r#additional_type_property = None;
2056					let mut r#alternate_name_property = None;
2057					let mut r#description_property = None;
2058					let mut r#disambiguating_description_property = None;
2059					let mut r#identifier_property = None;
2060					let mut r#image_property = None;
2061					let mut r#main_entity_of_page_property = None;
2062					let mut r#name_property = None;
2063					let mut r#potential_action_property = None;
2064					let mut r#same_as_property = None;
2065					let mut r#subject_of_property = None;
2066					let mut r#url_property = None;
2067					while let Some(key) = map.next_key::<Field>()? {
2068						match key {
2069							Field::AdditionalProperty => {
2070								if r#additional_property_property.is_some() {
2071									return Err(<A::Error as de::Error>::duplicate_field(
2072										"additionalProperty",
2073									));
2074								}
2075								r#additional_property_property = Some({
2076									struct DeserializeWith(Vec<AdditionalPropertyProperty>);
2077									impl<'de> Deserialize<'de> for DeserializeWith {
2078										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2079										where
2080											D: Deserializer<'de>,
2081										{
2082											Ok(DeserializeWith(serde_with::As::<
2083												serde_with::OneOrMany<serde_with::Same>,
2084											>::deserialize(deserializer)?))
2085										}
2086									}
2087									match map.next_value::<DeserializeWith>() {
2088										Ok(deserialize_with) => deserialize_with.0,
2089										Err(err) => {
2090											return Err(err);
2091										}
2092									}
2093								});
2094							}
2095							Field::Address => {
2096								if r#address_property.is_some() {
2097									return Err(<A::Error as de::Error>::duplicate_field(
2098										"address",
2099									));
2100								}
2101								r#address_property = Some({
2102									struct DeserializeWith(Vec<AddressProperty>);
2103									impl<'de> Deserialize<'de> for DeserializeWith {
2104										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2105										where
2106											D: Deserializer<'de>,
2107										{
2108											Ok(DeserializeWith(serde_with::As::<
2109												serde_with::OneOrMany<serde_with::Same>,
2110											>::deserialize(deserializer)?))
2111										}
2112									}
2113									match map.next_value::<DeserializeWith>() {
2114										Ok(deserialize_with) => deserialize_with.0,
2115										Err(err) => {
2116											return Err(err);
2117										}
2118									}
2119								});
2120							}
2121							Field::AggregateRating => {
2122								if r#aggregate_rating_property.is_some() {
2123									return Err(<A::Error as de::Error>::duplicate_field(
2124										"aggregateRating",
2125									));
2126								}
2127								r#aggregate_rating_property = Some({
2128									struct DeserializeWith(Vec<AggregateRatingProperty>);
2129									impl<'de> Deserialize<'de> for DeserializeWith {
2130										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2131										where
2132											D: Deserializer<'de>,
2133										{
2134											Ok(DeserializeWith(serde_with::As::<
2135												serde_with::OneOrMany<serde_with::Same>,
2136											>::deserialize(deserializer)?))
2137										}
2138									}
2139									match map.next_value::<DeserializeWith>() {
2140										Ok(deserialize_with) => deserialize_with.0,
2141										Err(err) => {
2142											return Err(err);
2143										}
2144									}
2145								});
2146							}
2147							Field::AmenityFeature => {
2148								if r#amenity_feature_property.is_some() {
2149									return Err(<A::Error as de::Error>::duplicate_field(
2150										"amenityFeature",
2151									));
2152								}
2153								r#amenity_feature_property = Some({
2154									struct DeserializeWith(Vec<AmenityFeatureProperty>);
2155									impl<'de> Deserialize<'de> for DeserializeWith {
2156										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2157										where
2158											D: Deserializer<'de>,
2159										{
2160											Ok(DeserializeWith(serde_with::As::<
2161												serde_with::OneOrMany<serde_with::Same>,
2162											>::deserialize(deserializer)?))
2163										}
2164									}
2165									match map.next_value::<DeserializeWith>() {
2166										Ok(deserialize_with) => deserialize_with.0,
2167										Err(err) => {
2168											return Err(err);
2169										}
2170									}
2171								});
2172							}
2173							Field::BranchCode => {
2174								if r#branch_code_property.is_some() {
2175									return Err(<A::Error as de::Error>::duplicate_field(
2176										"branchCode",
2177									));
2178								}
2179								r#branch_code_property = Some({
2180									struct DeserializeWith(Vec<BranchCodeProperty>);
2181									impl<'de> Deserialize<'de> for DeserializeWith {
2182										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2183										where
2184											D: Deserializer<'de>,
2185										{
2186											Ok(DeserializeWith(serde_with::As::<
2187												serde_with::OneOrMany<serde_with::Same>,
2188											>::deserialize(deserializer)?))
2189										}
2190									}
2191									match map.next_value::<DeserializeWith>() {
2192										Ok(deserialize_with) => deserialize_with.0,
2193										Err(err) => {
2194											return Err(err);
2195										}
2196									}
2197								});
2198							}
2199							Field::ContainedIn => {
2200								if r#contained_in_property.is_some() {
2201									return Err(<A::Error as de::Error>::duplicate_field(
2202										"containedIn",
2203									));
2204								}
2205								r#contained_in_property = Some({
2206									struct DeserializeWith(Vec<ContainedInProperty>);
2207									impl<'de> Deserialize<'de> for DeserializeWith {
2208										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2209										where
2210											D: Deserializer<'de>,
2211										{
2212											Ok(DeserializeWith(serde_with::As::<
2213												serde_with::OneOrMany<serde_with::Same>,
2214											>::deserialize(deserializer)?))
2215										}
2216									}
2217									match map.next_value::<DeserializeWith>() {
2218										Ok(deserialize_with) => deserialize_with.0,
2219										Err(err) => {
2220											return Err(err);
2221										}
2222									}
2223								});
2224							}
2225							Field::ContainedInPlace => {
2226								if r#contained_in_place_property.is_some() {
2227									return Err(<A::Error as de::Error>::duplicate_field(
2228										"containedInPlace",
2229									));
2230								}
2231								r#contained_in_place_property = Some({
2232									struct DeserializeWith(Vec<ContainedInPlaceProperty>);
2233									impl<'de> Deserialize<'de> for DeserializeWith {
2234										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2235										where
2236											D: Deserializer<'de>,
2237										{
2238											Ok(DeserializeWith(serde_with::As::<
2239												serde_with::OneOrMany<serde_with::Same>,
2240											>::deserialize(deserializer)?))
2241										}
2242									}
2243									match map.next_value::<DeserializeWith>() {
2244										Ok(deserialize_with) => deserialize_with.0,
2245										Err(err) => {
2246											return Err(err);
2247										}
2248									}
2249								});
2250							}
2251							Field::ContainsPlace => {
2252								if r#contains_place_property.is_some() {
2253									return Err(<A::Error as de::Error>::duplicate_field(
2254										"containsPlace",
2255									));
2256								}
2257								r#contains_place_property = Some({
2258									struct DeserializeWith(Vec<ContainsPlaceProperty>);
2259									impl<'de> Deserialize<'de> for DeserializeWith {
2260										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2261										where
2262											D: Deserializer<'de>,
2263										{
2264											Ok(DeserializeWith(serde_with::As::<
2265												serde_with::OneOrMany<serde_with::Same>,
2266											>::deserialize(deserializer)?))
2267										}
2268									}
2269									match map.next_value::<DeserializeWith>() {
2270										Ok(deserialize_with) => deserialize_with.0,
2271										Err(err) => {
2272											return Err(err);
2273										}
2274									}
2275								});
2276							}
2277							Field::Event => {
2278								if r#event_property.is_some() {
2279									return Err(<A::Error as de::Error>::duplicate_field("event"));
2280								}
2281								r#event_property = Some({
2282									struct DeserializeWith(Vec<EventProperty>);
2283									impl<'de> Deserialize<'de> for DeserializeWith {
2284										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2285										where
2286											D: Deserializer<'de>,
2287										{
2288											Ok(DeserializeWith(serde_with::As::<
2289												serde_with::OneOrMany<serde_with::Same>,
2290											>::deserialize(deserializer)?))
2291										}
2292									}
2293									match map.next_value::<DeserializeWith>() {
2294										Ok(deserialize_with) => deserialize_with.0,
2295										Err(err) => {
2296											return Err(err);
2297										}
2298									}
2299								});
2300							}
2301							Field::Events => {
2302								if r#events_property.is_some() {
2303									return Err(<A::Error as de::Error>::duplicate_field("events"));
2304								}
2305								r#events_property = Some({
2306									struct DeserializeWith(Vec<EventsProperty>);
2307									impl<'de> Deserialize<'de> for DeserializeWith {
2308										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2309										where
2310											D: Deserializer<'de>,
2311										{
2312											Ok(DeserializeWith(serde_with::As::<
2313												serde_with::OneOrMany<serde_with::Same>,
2314											>::deserialize(deserializer)?))
2315										}
2316									}
2317									match map.next_value::<DeserializeWith>() {
2318										Ok(deserialize_with) => deserialize_with.0,
2319										Err(err) => {
2320											return Err(err);
2321										}
2322									}
2323								});
2324							}
2325							Field::FaxNumber => {
2326								if r#fax_number_property.is_some() {
2327									return Err(<A::Error as de::Error>::duplicate_field(
2328										"faxNumber",
2329									));
2330								}
2331								r#fax_number_property = Some({
2332									struct DeserializeWith(Vec<FaxNumberProperty>);
2333									impl<'de> Deserialize<'de> for DeserializeWith {
2334										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2335										where
2336											D: Deserializer<'de>,
2337										{
2338											Ok(DeserializeWith(serde_with::As::<
2339												serde_with::OneOrMany<serde_with::Same>,
2340											>::deserialize(deserializer)?))
2341										}
2342									}
2343									match map.next_value::<DeserializeWith>() {
2344										Ok(deserialize_with) => deserialize_with.0,
2345										Err(err) => {
2346											return Err(err);
2347										}
2348									}
2349								});
2350							}
2351							Field::Geo => {
2352								if r#geo_property.is_some() {
2353									return Err(<A::Error as de::Error>::duplicate_field("geo"));
2354								}
2355								r#geo_property = Some({
2356									struct DeserializeWith(Vec<GeoProperty>);
2357									impl<'de> Deserialize<'de> for DeserializeWith {
2358										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2359										where
2360											D: Deserializer<'de>,
2361										{
2362											Ok(DeserializeWith(serde_with::As::<
2363												serde_with::OneOrMany<serde_with::Same>,
2364											>::deserialize(deserializer)?))
2365										}
2366									}
2367									match map.next_value::<DeserializeWith>() {
2368										Ok(deserialize_with) => deserialize_with.0,
2369										Err(err) => {
2370											return Err(err);
2371										}
2372									}
2373								});
2374							}
2375							Field::GeoContains => {
2376								if r#geo_contains_property.is_some() {
2377									return Err(<A::Error as de::Error>::duplicate_field(
2378										"geoContains",
2379									));
2380								}
2381								r#geo_contains_property = Some({
2382									struct DeserializeWith(Vec<GeoContainsProperty>);
2383									impl<'de> Deserialize<'de> for DeserializeWith {
2384										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2385										where
2386											D: Deserializer<'de>,
2387										{
2388											Ok(DeserializeWith(serde_with::As::<
2389												serde_with::OneOrMany<serde_with::Same>,
2390											>::deserialize(deserializer)?))
2391										}
2392									}
2393									match map.next_value::<DeserializeWith>() {
2394										Ok(deserialize_with) => deserialize_with.0,
2395										Err(err) => {
2396											return Err(err);
2397										}
2398									}
2399								});
2400							}
2401							Field::GeoCoveredBy => {
2402								if r#geo_covered_by_property.is_some() {
2403									return Err(<A::Error as de::Error>::duplicate_field(
2404										"geoCoveredBy",
2405									));
2406								}
2407								r#geo_covered_by_property = Some({
2408									struct DeserializeWith(Vec<GeoCoveredByProperty>);
2409									impl<'de> Deserialize<'de> for DeserializeWith {
2410										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2411										where
2412											D: Deserializer<'de>,
2413										{
2414											Ok(DeserializeWith(serde_with::As::<
2415												serde_with::OneOrMany<serde_with::Same>,
2416											>::deserialize(deserializer)?))
2417										}
2418									}
2419									match map.next_value::<DeserializeWith>() {
2420										Ok(deserialize_with) => deserialize_with.0,
2421										Err(err) => {
2422											return Err(err);
2423										}
2424									}
2425								});
2426							}
2427							Field::GeoCovers => {
2428								if r#geo_covers_property.is_some() {
2429									return Err(<A::Error as de::Error>::duplicate_field(
2430										"geoCovers",
2431									));
2432								}
2433								r#geo_covers_property = Some({
2434									struct DeserializeWith(Vec<GeoCoversProperty>);
2435									impl<'de> Deserialize<'de> for DeserializeWith {
2436										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2437										where
2438											D: Deserializer<'de>,
2439										{
2440											Ok(DeserializeWith(serde_with::As::<
2441												serde_with::OneOrMany<serde_with::Same>,
2442											>::deserialize(deserializer)?))
2443										}
2444									}
2445									match map.next_value::<DeserializeWith>() {
2446										Ok(deserialize_with) => deserialize_with.0,
2447										Err(err) => {
2448											return Err(err);
2449										}
2450									}
2451								});
2452							}
2453							Field::GeoCrosses => {
2454								if r#geo_crosses_property.is_some() {
2455									return Err(<A::Error as de::Error>::duplicate_field(
2456										"geoCrosses",
2457									));
2458								}
2459								r#geo_crosses_property = Some({
2460									struct DeserializeWith(Vec<GeoCrossesProperty>);
2461									impl<'de> Deserialize<'de> for DeserializeWith {
2462										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2463										where
2464											D: Deserializer<'de>,
2465										{
2466											Ok(DeserializeWith(serde_with::As::<
2467												serde_with::OneOrMany<serde_with::Same>,
2468											>::deserialize(deserializer)?))
2469										}
2470									}
2471									match map.next_value::<DeserializeWith>() {
2472										Ok(deserialize_with) => deserialize_with.0,
2473										Err(err) => {
2474											return Err(err);
2475										}
2476									}
2477								});
2478							}
2479							Field::GeoDisjoint => {
2480								if r#geo_disjoint_property.is_some() {
2481									return Err(<A::Error as de::Error>::duplicate_field(
2482										"geoDisjoint",
2483									));
2484								}
2485								r#geo_disjoint_property = Some({
2486									struct DeserializeWith(Vec<GeoDisjointProperty>);
2487									impl<'de> Deserialize<'de> for DeserializeWith {
2488										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2489										where
2490											D: Deserializer<'de>,
2491										{
2492											Ok(DeserializeWith(serde_with::As::<
2493												serde_with::OneOrMany<serde_with::Same>,
2494											>::deserialize(deserializer)?))
2495										}
2496									}
2497									match map.next_value::<DeserializeWith>() {
2498										Ok(deserialize_with) => deserialize_with.0,
2499										Err(err) => {
2500											return Err(err);
2501										}
2502									}
2503								});
2504							}
2505							Field::GeoEquals => {
2506								if r#geo_equals_property.is_some() {
2507									return Err(<A::Error as de::Error>::duplicate_field(
2508										"geoEquals",
2509									));
2510								}
2511								r#geo_equals_property = Some({
2512									struct DeserializeWith(Vec<GeoEqualsProperty>);
2513									impl<'de> Deserialize<'de> for DeserializeWith {
2514										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2515										where
2516											D: Deserializer<'de>,
2517										{
2518											Ok(DeserializeWith(serde_with::As::<
2519												serde_with::OneOrMany<serde_with::Same>,
2520											>::deserialize(deserializer)?))
2521										}
2522									}
2523									match map.next_value::<DeserializeWith>() {
2524										Ok(deserialize_with) => deserialize_with.0,
2525										Err(err) => {
2526											return Err(err);
2527										}
2528									}
2529								});
2530							}
2531							Field::GeoIntersects => {
2532								if r#geo_intersects_property.is_some() {
2533									return Err(<A::Error as de::Error>::duplicate_field(
2534										"geoIntersects",
2535									));
2536								}
2537								r#geo_intersects_property = Some({
2538									struct DeserializeWith(Vec<GeoIntersectsProperty>);
2539									impl<'de> Deserialize<'de> for DeserializeWith {
2540										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2541										where
2542											D: Deserializer<'de>,
2543										{
2544											Ok(DeserializeWith(serde_with::As::<
2545												serde_with::OneOrMany<serde_with::Same>,
2546											>::deserialize(deserializer)?))
2547										}
2548									}
2549									match map.next_value::<DeserializeWith>() {
2550										Ok(deserialize_with) => deserialize_with.0,
2551										Err(err) => {
2552											return Err(err);
2553										}
2554									}
2555								});
2556							}
2557							Field::GeoOverlaps => {
2558								if r#geo_overlaps_property.is_some() {
2559									return Err(<A::Error as de::Error>::duplicate_field(
2560										"geoOverlaps",
2561									));
2562								}
2563								r#geo_overlaps_property = Some({
2564									struct DeserializeWith(Vec<GeoOverlapsProperty>);
2565									impl<'de> Deserialize<'de> for DeserializeWith {
2566										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2567										where
2568											D: Deserializer<'de>,
2569										{
2570											Ok(DeserializeWith(serde_with::As::<
2571												serde_with::OneOrMany<serde_with::Same>,
2572											>::deserialize(deserializer)?))
2573										}
2574									}
2575									match map.next_value::<DeserializeWith>() {
2576										Ok(deserialize_with) => deserialize_with.0,
2577										Err(err) => {
2578											return Err(err);
2579										}
2580									}
2581								});
2582							}
2583							Field::GeoTouches => {
2584								if r#geo_touches_property.is_some() {
2585									return Err(<A::Error as de::Error>::duplicate_field(
2586										"geoTouches",
2587									));
2588								}
2589								r#geo_touches_property = Some({
2590									struct DeserializeWith(Vec<GeoTouchesProperty>);
2591									impl<'de> Deserialize<'de> for DeserializeWith {
2592										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2593										where
2594											D: Deserializer<'de>,
2595										{
2596											Ok(DeserializeWith(serde_with::As::<
2597												serde_with::OneOrMany<serde_with::Same>,
2598											>::deserialize(deserializer)?))
2599										}
2600									}
2601									match map.next_value::<DeserializeWith>() {
2602										Ok(deserialize_with) => deserialize_with.0,
2603										Err(err) => {
2604											return Err(err);
2605										}
2606									}
2607								});
2608							}
2609							Field::GeoWithin => {
2610								if r#geo_within_property.is_some() {
2611									return Err(<A::Error as de::Error>::duplicate_field(
2612										"geoWithin",
2613									));
2614								}
2615								r#geo_within_property = Some({
2616									struct DeserializeWith(Vec<GeoWithinProperty>);
2617									impl<'de> Deserialize<'de> for DeserializeWith {
2618										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2619										where
2620											D: Deserializer<'de>,
2621										{
2622											Ok(DeserializeWith(serde_with::As::<
2623												serde_with::OneOrMany<serde_with::Same>,
2624											>::deserialize(deserializer)?))
2625										}
2626									}
2627									match map.next_value::<DeserializeWith>() {
2628										Ok(deserialize_with) => deserialize_with.0,
2629										Err(err) => {
2630											return Err(err);
2631										}
2632									}
2633								});
2634							}
2635							Field::GlobalLocationNumber => {
2636								if r#global_location_number_property.is_some() {
2637									return Err(<A::Error as de::Error>::duplicate_field(
2638										"globalLocationNumber",
2639									));
2640								}
2641								r#global_location_number_property = Some({
2642									struct DeserializeWith(Vec<GlobalLocationNumberProperty>);
2643									impl<'de> Deserialize<'de> for DeserializeWith {
2644										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2645										where
2646											D: Deserializer<'de>,
2647										{
2648											Ok(DeserializeWith(serde_with::As::<
2649												serde_with::OneOrMany<serde_with::Same>,
2650											>::deserialize(deserializer)?))
2651										}
2652									}
2653									match map.next_value::<DeserializeWith>() {
2654										Ok(deserialize_with) => deserialize_with.0,
2655										Err(err) => {
2656											return Err(err);
2657										}
2658									}
2659								});
2660							}
2661							Field::HasDriveThroughService => {
2662								if r#has_drive_through_service_property.is_some() {
2663									return Err(<A::Error as de::Error>::duplicate_field(
2664										"hasDriveThroughService",
2665									));
2666								}
2667								r#has_drive_through_service_property = Some({
2668									struct DeserializeWith(Vec<HasDriveThroughServiceProperty>);
2669									impl<'de> Deserialize<'de> for DeserializeWith {
2670										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2671										where
2672											D: Deserializer<'de>,
2673										{
2674											Ok(DeserializeWith(serde_with::As::<
2675												serde_with::OneOrMany<serde_with::Same>,
2676											>::deserialize(deserializer)?))
2677										}
2678									}
2679									match map.next_value::<DeserializeWith>() {
2680										Ok(deserialize_with) => deserialize_with.0,
2681										Err(err) => {
2682											return Err(err);
2683										}
2684									}
2685								});
2686							}
2687							Field::HasMap => {
2688								if r#has_map_property.is_some() {
2689									return Err(<A::Error as de::Error>::duplicate_field("hasMap"));
2690								}
2691								r#has_map_property = Some({
2692									struct DeserializeWith(Vec<HasMapProperty>);
2693									impl<'de> Deserialize<'de> for DeserializeWith {
2694										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2695										where
2696											D: Deserializer<'de>,
2697										{
2698											Ok(DeserializeWith(serde_with::As::<
2699												serde_with::OneOrMany<serde_with::Same>,
2700											>::deserialize(deserializer)?))
2701										}
2702									}
2703									match map.next_value::<DeserializeWith>() {
2704										Ok(deserialize_with) => deserialize_with.0,
2705										Err(err) => {
2706											return Err(err);
2707										}
2708									}
2709								});
2710							}
2711							Field::IsAccessibleForFree => {
2712								if r#is_accessible_for_free_property.is_some() {
2713									return Err(<A::Error as de::Error>::duplicate_field(
2714										"isAccessibleForFree",
2715									));
2716								}
2717								r#is_accessible_for_free_property = Some({
2718									struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
2719									impl<'de> Deserialize<'de> for DeserializeWith {
2720										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2721										where
2722											D: Deserializer<'de>,
2723										{
2724											Ok(DeserializeWith(serde_with::As::<
2725												serde_with::OneOrMany<serde_with::Same>,
2726											>::deserialize(deserializer)?))
2727										}
2728									}
2729									match map.next_value::<DeserializeWith>() {
2730										Ok(deserialize_with) => deserialize_with.0,
2731										Err(err) => {
2732											return Err(err);
2733										}
2734									}
2735								});
2736							}
2737							Field::IsicV4 => {
2738								if r#isic_v_4_property.is_some() {
2739									return Err(<A::Error as de::Error>::duplicate_field("isicV4"));
2740								}
2741								r#isic_v_4_property = Some({
2742									struct DeserializeWith(Vec<IsicV4Property>);
2743									impl<'de> Deserialize<'de> for DeserializeWith {
2744										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2745										where
2746											D: Deserializer<'de>,
2747										{
2748											Ok(DeserializeWith(serde_with::As::<
2749												serde_with::OneOrMany<serde_with::Same>,
2750											>::deserialize(deserializer)?))
2751										}
2752									}
2753									match map.next_value::<DeserializeWith>() {
2754										Ok(deserialize_with) => deserialize_with.0,
2755										Err(err) => {
2756											return Err(err);
2757										}
2758									}
2759								});
2760							}
2761							Field::Keywords => {
2762								if r#keywords_property.is_some() {
2763									return Err(<A::Error as de::Error>::duplicate_field(
2764										"keywords",
2765									));
2766								}
2767								r#keywords_property = Some({
2768									struct DeserializeWith(Vec<KeywordsProperty>);
2769									impl<'de> Deserialize<'de> for DeserializeWith {
2770										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2771										where
2772											D: Deserializer<'de>,
2773										{
2774											Ok(DeserializeWith(serde_with::As::<
2775												serde_with::OneOrMany<serde_with::Same>,
2776											>::deserialize(deserializer)?))
2777										}
2778									}
2779									match map.next_value::<DeserializeWith>() {
2780										Ok(deserialize_with) => deserialize_with.0,
2781										Err(err) => {
2782											return Err(err);
2783										}
2784									}
2785								});
2786							}
2787							Field::Latitude => {
2788								if r#latitude_property.is_some() {
2789									return Err(<A::Error as de::Error>::duplicate_field(
2790										"latitude",
2791									));
2792								}
2793								r#latitude_property = Some({
2794									struct DeserializeWith(Vec<LatitudeProperty>);
2795									impl<'de> Deserialize<'de> for DeserializeWith {
2796										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2797										where
2798											D: Deserializer<'de>,
2799										{
2800											Ok(DeserializeWith(serde_with::As::<
2801												serde_with::OneOrMany<serde_with::Same>,
2802											>::deserialize(deserializer)?))
2803										}
2804									}
2805									match map.next_value::<DeserializeWith>() {
2806										Ok(deserialize_with) => deserialize_with.0,
2807										Err(err) => {
2808											return Err(err);
2809										}
2810									}
2811								});
2812							}
2813							Field::Logo => {
2814								if r#logo_property.is_some() {
2815									return Err(<A::Error as de::Error>::duplicate_field("logo"));
2816								}
2817								r#logo_property = Some({
2818									struct DeserializeWith(Vec<LogoProperty>);
2819									impl<'de> Deserialize<'de> for DeserializeWith {
2820										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2821										where
2822											D: Deserializer<'de>,
2823										{
2824											Ok(DeserializeWith(serde_with::As::<
2825												serde_with::OneOrMany<serde_with::Same>,
2826											>::deserialize(deserializer)?))
2827										}
2828									}
2829									match map.next_value::<DeserializeWith>() {
2830										Ok(deserialize_with) => deserialize_with.0,
2831										Err(err) => {
2832											return Err(err);
2833										}
2834									}
2835								});
2836							}
2837							Field::Longitude => {
2838								if r#longitude_property.is_some() {
2839									return Err(<A::Error as de::Error>::duplicate_field(
2840										"longitude",
2841									));
2842								}
2843								r#longitude_property = Some({
2844									struct DeserializeWith(Vec<LongitudeProperty>);
2845									impl<'de> Deserialize<'de> for DeserializeWith {
2846										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2847										where
2848											D: Deserializer<'de>,
2849										{
2850											Ok(DeserializeWith(serde_with::As::<
2851												serde_with::OneOrMany<serde_with::Same>,
2852											>::deserialize(deserializer)?))
2853										}
2854									}
2855									match map.next_value::<DeserializeWith>() {
2856										Ok(deserialize_with) => deserialize_with.0,
2857										Err(err) => {
2858											return Err(err);
2859										}
2860									}
2861								});
2862							}
2863							Field::Map => {
2864								if r#map_property.is_some() {
2865									return Err(<A::Error as de::Error>::duplicate_field("map"));
2866								}
2867								r#map_property = Some({
2868									struct DeserializeWith(Vec<MapProperty>);
2869									impl<'de> Deserialize<'de> for DeserializeWith {
2870										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2871										where
2872											D: Deserializer<'de>,
2873										{
2874											Ok(DeserializeWith(serde_with::As::<
2875												serde_with::OneOrMany<serde_with::Same>,
2876											>::deserialize(deserializer)?))
2877										}
2878									}
2879									match map.next_value::<DeserializeWith>() {
2880										Ok(deserialize_with) => deserialize_with.0,
2881										Err(err) => {
2882											return Err(err);
2883										}
2884									}
2885								});
2886							}
2887							Field::Maps => {
2888								if r#maps_property.is_some() {
2889									return Err(<A::Error as de::Error>::duplicate_field("maps"));
2890								}
2891								r#maps_property = Some({
2892									struct DeserializeWith(Vec<MapsProperty>);
2893									impl<'de> Deserialize<'de> for DeserializeWith {
2894										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2895										where
2896											D: Deserializer<'de>,
2897										{
2898											Ok(DeserializeWith(serde_with::As::<
2899												serde_with::OneOrMany<serde_with::Same>,
2900											>::deserialize(deserializer)?))
2901										}
2902									}
2903									match map.next_value::<DeserializeWith>() {
2904										Ok(deserialize_with) => deserialize_with.0,
2905										Err(err) => {
2906											return Err(err);
2907										}
2908									}
2909								});
2910							}
2911							Field::MaximumAttendeeCapacity => {
2912								if r#maximum_attendee_capacity_property.is_some() {
2913									return Err(<A::Error as de::Error>::duplicate_field(
2914										"maximumAttendeeCapacity",
2915									));
2916								}
2917								r#maximum_attendee_capacity_property = Some({
2918									struct DeserializeWith(Vec<MaximumAttendeeCapacityProperty>);
2919									impl<'de> Deserialize<'de> for DeserializeWith {
2920										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2921										where
2922											D: Deserializer<'de>,
2923										{
2924											Ok(DeserializeWith(serde_with::As::<
2925												serde_with::OneOrMany<serde_with::Same>,
2926											>::deserialize(deserializer)?))
2927										}
2928									}
2929									match map.next_value::<DeserializeWith>() {
2930										Ok(deserialize_with) => deserialize_with.0,
2931										Err(err) => {
2932											return Err(err);
2933										}
2934									}
2935								});
2936							}
2937							Field::OpeningHoursSpecification => {
2938								if r#opening_hours_specification_property.is_some() {
2939									return Err(<A::Error as de::Error>::duplicate_field(
2940										"openingHoursSpecification",
2941									));
2942								}
2943								r#opening_hours_specification_property = Some({
2944									struct DeserializeWith(Vec<OpeningHoursSpecificationProperty>);
2945									impl<'de> Deserialize<'de> for DeserializeWith {
2946										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2947										where
2948											D: Deserializer<'de>,
2949										{
2950											Ok(DeserializeWith(serde_with::As::<
2951												serde_with::OneOrMany<serde_with::Same>,
2952											>::deserialize(deserializer)?))
2953										}
2954									}
2955									match map.next_value::<DeserializeWith>() {
2956										Ok(deserialize_with) => deserialize_with.0,
2957										Err(err) => {
2958											return Err(err);
2959										}
2960									}
2961								});
2962							}
2963							Field::Photo => {
2964								if r#photo_property.is_some() {
2965									return Err(<A::Error as de::Error>::duplicate_field("photo"));
2966								}
2967								r#photo_property = Some({
2968									struct DeserializeWith(Vec<PhotoProperty>);
2969									impl<'de> Deserialize<'de> for DeserializeWith {
2970										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2971										where
2972											D: Deserializer<'de>,
2973										{
2974											Ok(DeserializeWith(serde_with::As::<
2975												serde_with::OneOrMany<serde_with::Same>,
2976											>::deserialize(deserializer)?))
2977										}
2978									}
2979									match map.next_value::<DeserializeWith>() {
2980										Ok(deserialize_with) => deserialize_with.0,
2981										Err(err) => {
2982											return Err(err);
2983										}
2984									}
2985								});
2986							}
2987							Field::Photos => {
2988								if r#photos_property.is_some() {
2989									return Err(<A::Error as de::Error>::duplicate_field("photos"));
2990								}
2991								r#photos_property = Some({
2992									struct DeserializeWith(Vec<PhotosProperty>);
2993									impl<'de> Deserialize<'de> for DeserializeWith {
2994										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2995										where
2996											D: Deserializer<'de>,
2997										{
2998											Ok(DeserializeWith(serde_with::As::<
2999												serde_with::OneOrMany<serde_with::Same>,
3000											>::deserialize(deserializer)?))
3001										}
3002									}
3003									match map.next_value::<DeserializeWith>() {
3004										Ok(deserialize_with) => deserialize_with.0,
3005										Err(err) => {
3006											return Err(err);
3007										}
3008									}
3009								});
3010							}
3011							Field::PublicAccess => {
3012								if r#public_access_property.is_some() {
3013									return Err(<A::Error as de::Error>::duplicate_field(
3014										"publicAccess",
3015									));
3016								}
3017								r#public_access_property = Some({
3018									struct DeserializeWith(Vec<PublicAccessProperty>);
3019									impl<'de> Deserialize<'de> for DeserializeWith {
3020										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3021										where
3022											D: Deserializer<'de>,
3023										{
3024											Ok(DeserializeWith(serde_with::As::<
3025												serde_with::OneOrMany<serde_with::Same>,
3026											>::deserialize(deserializer)?))
3027										}
3028									}
3029									match map.next_value::<DeserializeWith>() {
3030										Ok(deserialize_with) => deserialize_with.0,
3031										Err(err) => {
3032											return Err(err);
3033										}
3034									}
3035								});
3036							}
3037							Field::Review => {
3038								if r#review_property.is_some() {
3039									return Err(<A::Error as de::Error>::duplicate_field("review"));
3040								}
3041								r#review_property = Some({
3042									struct DeserializeWith(Vec<ReviewProperty>);
3043									impl<'de> Deserialize<'de> for DeserializeWith {
3044										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3045										where
3046											D: Deserializer<'de>,
3047										{
3048											Ok(DeserializeWith(serde_with::As::<
3049												serde_with::OneOrMany<serde_with::Same>,
3050											>::deserialize(deserializer)?))
3051										}
3052									}
3053									match map.next_value::<DeserializeWith>() {
3054										Ok(deserialize_with) => deserialize_with.0,
3055										Err(err) => {
3056											return Err(err);
3057										}
3058									}
3059								});
3060							}
3061							Field::Reviews => {
3062								if r#reviews_property.is_some() {
3063									return Err(<A::Error as de::Error>::duplicate_field(
3064										"reviews",
3065									));
3066								}
3067								r#reviews_property = Some({
3068									struct DeserializeWith(Vec<ReviewsProperty>);
3069									impl<'de> Deserialize<'de> for DeserializeWith {
3070										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3071										where
3072											D: Deserializer<'de>,
3073										{
3074											Ok(DeserializeWith(serde_with::As::<
3075												serde_with::OneOrMany<serde_with::Same>,
3076											>::deserialize(deserializer)?))
3077										}
3078									}
3079									match map.next_value::<DeserializeWith>() {
3080										Ok(deserialize_with) => deserialize_with.0,
3081										Err(err) => {
3082											return Err(err);
3083										}
3084									}
3085								});
3086							}
3087							Field::Slogan => {
3088								if r#slogan_property.is_some() {
3089									return Err(<A::Error as de::Error>::duplicate_field("slogan"));
3090								}
3091								r#slogan_property = Some({
3092									struct DeserializeWith(Vec<SloganProperty>);
3093									impl<'de> Deserialize<'de> for DeserializeWith {
3094										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3095										where
3096											D: Deserializer<'de>,
3097										{
3098											Ok(DeserializeWith(serde_with::As::<
3099												serde_with::OneOrMany<serde_with::Same>,
3100											>::deserialize(deserializer)?))
3101										}
3102									}
3103									match map.next_value::<DeserializeWith>() {
3104										Ok(deserialize_with) => deserialize_with.0,
3105										Err(err) => {
3106											return Err(err);
3107										}
3108									}
3109								});
3110							}
3111							Field::SmokingAllowed => {
3112								if r#smoking_allowed_property.is_some() {
3113									return Err(<A::Error as de::Error>::duplicate_field(
3114										"smokingAllowed",
3115									));
3116								}
3117								r#smoking_allowed_property = Some({
3118									struct DeserializeWith(Vec<SmokingAllowedProperty>);
3119									impl<'de> Deserialize<'de> for DeserializeWith {
3120										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3121										where
3122											D: Deserializer<'de>,
3123										{
3124											Ok(DeserializeWith(serde_with::As::<
3125												serde_with::OneOrMany<serde_with::Same>,
3126											>::deserialize(deserializer)?))
3127										}
3128									}
3129									match map.next_value::<DeserializeWith>() {
3130										Ok(deserialize_with) => deserialize_with.0,
3131										Err(err) => {
3132											return Err(err);
3133										}
3134									}
3135								});
3136							}
3137							Field::SpecialOpeningHoursSpecification => {
3138								if r#special_opening_hours_specification_property.is_some() {
3139									return Err(<A::Error as de::Error>::duplicate_field(
3140										"specialOpeningHoursSpecification",
3141									));
3142								}
3143								r#special_opening_hours_specification_property = Some({
3144									struct DeserializeWith(
3145										Vec<SpecialOpeningHoursSpecificationProperty>,
3146									);
3147									impl<'de> Deserialize<'de> for DeserializeWith {
3148										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3149										where
3150											D: Deserializer<'de>,
3151										{
3152											Ok(DeserializeWith(serde_with::As::<
3153												serde_with::OneOrMany<serde_with::Same>,
3154											>::deserialize(deserializer)?))
3155										}
3156									}
3157									match map.next_value::<DeserializeWith>() {
3158										Ok(deserialize_with) => deserialize_with.0,
3159										Err(err) => {
3160											return Err(err);
3161										}
3162									}
3163								});
3164							}
3165							Field::Telephone => {
3166								if r#telephone_property.is_some() {
3167									return Err(<A::Error as de::Error>::duplicate_field(
3168										"telephone",
3169									));
3170								}
3171								r#telephone_property = Some({
3172									struct DeserializeWith(Vec<TelephoneProperty>);
3173									impl<'de> Deserialize<'de> for DeserializeWith {
3174										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3175										where
3176											D: Deserializer<'de>,
3177										{
3178											Ok(DeserializeWith(serde_with::As::<
3179												serde_with::OneOrMany<serde_with::Same>,
3180											>::deserialize(deserializer)?))
3181										}
3182									}
3183									match map.next_value::<DeserializeWith>() {
3184										Ok(deserialize_with) => deserialize_with.0,
3185										Err(err) => {
3186											return Err(err);
3187										}
3188									}
3189								});
3190							}
3191							Field::TourBookingPage => {
3192								if r#tour_booking_page_property.is_some() {
3193									return Err(<A::Error as de::Error>::duplicate_field(
3194										"tourBookingPage",
3195									));
3196								}
3197								r#tour_booking_page_property = Some({
3198									struct DeserializeWith(Vec<TourBookingPageProperty>);
3199									impl<'de> Deserialize<'de> for DeserializeWith {
3200										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3201										where
3202											D: Deserializer<'de>,
3203										{
3204											Ok(DeserializeWith(serde_with::As::<
3205												serde_with::OneOrMany<serde_with::Same>,
3206											>::deserialize(deserializer)?))
3207										}
3208									}
3209									match map.next_value::<DeserializeWith>() {
3210										Ok(deserialize_with) => deserialize_with.0,
3211										Err(err) => {
3212											return Err(err);
3213										}
3214									}
3215								});
3216							}
3217							Field::AdditionalType => {
3218								if r#additional_type_property.is_some() {
3219									return Err(<A::Error as de::Error>::duplicate_field(
3220										"additionalType",
3221									));
3222								}
3223								r#additional_type_property = Some({
3224									struct DeserializeWith(Vec<AdditionalTypeProperty>);
3225									impl<'de> Deserialize<'de> for DeserializeWith {
3226										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3227										where
3228											D: Deserializer<'de>,
3229										{
3230											Ok(DeserializeWith(serde_with::As::<
3231												serde_with::OneOrMany<serde_with::Same>,
3232											>::deserialize(deserializer)?))
3233										}
3234									}
3235									match map.next_value::<DeserializeWith>() {
3236										Ok(deserialize_with) => deserialize_with.0,
3237										Err(err) => {
3238											return Err(err);
3239										}
3240									}
3241								});
3242							}
3243							Field::AlternateName => {
3244								if r#alternate_name_property.is_some() {
3245									return Err(<A::Error as de::Error>::duplicate_field(
3246										"alternateName",
3247									));
3248								}
3249								r#alternate_name_property = Some({
3250									struct DeserializeWith(Vec<AlternateNameProperty>);
3251									impl<'de> Deserialize<'de> for DeserializeWith {
3252										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3253										where
3254											D: Deserializer<'de>,
3255										{
3256											Ok(DeserializeWith(serde_with::As::<
3257												serde_with::OneOrMany<serde_with::Same>,
3258											>::deserialize(deserializer)?))
3259										}
3260									}
3261									match map.next_value::<DeserializeWith>() {
3262										Ok(deserialize_with) => deserialize_with.0,
3263										Err(err) => {
3264											return Err(err);
3265										}
3266									}
3267								});
3268							}
3269							Field::Description => {
3270								if r#description_property.is_some() {
3271									return Err(<A::Error as de::Error>::duplicate_field(
3272										"description",
3273									));
3274								}
3275								r#description_property = Some({
3276									struct DeserializeWith(Vec<DescriptionProperty>);
3277									impl<'de> Deserialize<'de> for DeserializeWith {
3278										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3279										where
3280											D: Deserializer<'de>,
3281										{
3282											Ok(DeserializeWith(serde_with::As::<
3283												serde_with::OneOrMany<serde_with::Same>,
3284											>::deserialize(deserializer)?))
3285										}
3286									}
3287									match map.next_value::<DeserializeWith>() {
3288										Ok(deserialize_with) => deserialize_with.0,
3289										Err(err) => {
3290											return Err(err);
3291										}
3292									}
3293								});
3294							}
3295							Field::DisambiguatingDescription => {
3296								if r#disambiguating_description_property.is_some() {
3297									return Err(<A::Error as de::Error>::duplicate_field(
3298										"disambiguatingDescription",
3299									));
3300								}
3301								r#disambiguating_description_property = Some({
3302									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
3303									impl<'de> Deserialize<'de> for DeserializeWith {
3304										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3305										where
3306											D: Deserializer<'de>,
3307										{
3308											Ok(DeserializeWith(serde_with::As::<
3309												serde_with::OneOrMany<serde_with::Same>,
3310											>::deserialize(deserializer)?))
3311										}
3312									}
3313									match map.next_value::<DeserializeWith>() {
3314										Ok(deserialize_with) => deserialize_with.0,
3315										Err(err) => {
3316											return Err(err);
3317										}
3318									}
3319								});
3320							}
3321							Field::Identifier => {
3322								if r#identifier_property.is_some() {
3323									return Err(<A::Error as de::Error>::duplicate_field(
3324										"identifier",
3325									));
3326								}
3327								r#identifier_property = Some({
3328									struct DeserializeWith(Vec<IdentifierProperty>);
3329									impl<'de> Deserialize<'de> for DeserializeWith {
3330										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3331										where
3332											D: Deserializer<'de>,
3333										{
3334											Ok(DeserializeWith(serde_with::As::<
3335												serde_with::OneOrMany<serde_with::Same>,
3336											>::deserialize(deserializer)?))
3337										}
3338									}
3339									match map.next_value::<DeserializeWith>() {
3340										Ok(deserialize_with) => deserialize_with.0,
3341										Err(err) => {
3342											return Err(err);
3343										}
3344									}
3345								});
3346							}
3347							Field::Image => {
3348								if r#image_property.is_some() {
3349									return Err(<A::Error as de::Error>::duplicate_field("image"));
3350								}
3351								r#image_property = Some({
3352									struct DeserializeWith(Vec<ImageProperty>);
3353									impl<'de> Deserialize<'de> for DeserializeWith {
3354										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3355										where
3356											D: Deserializer<'de>,
3357										{
3358											Ok(DeserializeWith(serde_with::As::<
3359												serde_with::OneOrMany<serde_with::Same>,
3360											>::deserialize(deserializer)?))
3361										}
3362									}
3363									match map.next_value::<DeserializeWith>() {
3364										Ok(deserialize_with) => deserialize_with.0,
3365										Err(err) => {
3366											return Err(err);
3367										}
3368									}
3369								});
3370							}
3371							Field::MainEntityOfPage => {
3372								if r#main_entity_of_page_property.is_some() {
3373									return Err(<A::Error as de::Error>::duplicate_field(
3374										"mainEntityOfPage",
3375									));
3376								}
3377								r#main_entity_of_page_property = Some({
3378									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
3379									impl<'de> Deserialize<'de> for DeserializeWith {
3380										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3381										where
3382											D: Deserializer<'de>,
3383										{
3384											Ok(DeserializeWith(serde_with::As::<
3385												serde_with::OneOrMany<serde_with::Same>,
3386											>::deserialize(deserializer)?))
3387										}
3388									}
3389									match map.next_value::<DeserializeWith>() {
3390										Ok(deserialize_with) => deserialize_with.0,
3391										Err(err) => {
3392											return Err(err);
3393										}
3394									}
3395								});
3396							}
3397							Field::Name => {
3398								if r#name_property.is_some() {
3399									return Err(<A::Error as de::Error>::duplicate_field("name"));
3400								}
3401								r#name_property = Some({
3402									struct DeserializeWith(Vec<NameProperty>);
3403									impl<'de> Deserialize<'de> for DeserializeWith {
3404										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3405										where
3406											D: Deserializer<'de>,
3407										{
3408											Ok(DeserializeWith(serde_with::As::<
3409												serde_with::OneOrMany<serde_with::Same>,
3410											>::deserialize(deserializer)?))
3411										}
3412									}
3413									match map.next_value::<DeserializeWith>() {
3414										Ok(deserialize_with) => deserialize_with.0,
3415										Err(err) => {
3416											return Err(err);
3417										}
3418									}
3419								});
3420							}
3421							Field::PotentialAction => {
3422								if r#potential_action_property.is_some() {
3423									return Err(<A::Error as de::Error>::duplicate_field(
3424										"potentialAction",
3425									));
3426								}
3427								r#potential_action_property = Some({
3428									struct DeserializeWith(Vec<PotentialActionProperty>);
3429									impl<'de> Deserialize<'de> for DeserializeWith {
3430										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3431										where
3432											D: Deserializer<'de>,
3433										{
3434											Ok(DeserializeWith(serde_with::As::<
3435												serde_with::OneOrMany<serde_with::Same>,
3436											>::deserialize(deserializer)?))
3437										}
3438									}
3439									match map.next_value::<DeserializeWith>() {
3440										Ok(deserialize_with) => deserialize_with.0,
3441										Err(err) => {
3442											return Err(err);
3443										}
3444									}
3445								});
3446							}
3447							Field::SameAs => {
3448								if r#same_as_property.is_some() {
3449									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
3450								}
3451								r#same_as_property = Some({
3452									struct DeserializeWith(Vec<SameAsProperty>);
3453									impl<'de> Deserialize<'de> for DeserializeWith {
3454										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3455										where
3456											D: Deserializer<'de>,
3457										{
3458											Ok(DeserializeWith(serde_with::As::<
3459												serde_with::OneOrMany<serde_with::Same>,
3460											>::deserialize(deserializer)?))
3461										}
3462									}
3463									match map.next_value::<DeserializeWith>() {
3464										Ok(deserialize_with) => deserialize_with.0,
3465										Err(err) => {
3466											return Err(err);
3467										}
3468									}
3469								});
3470							}
3471							Field::SubjectOf => {
3472								if r#subject_of_property.is_some() {
3473									return Err(<A::Error as de::Error>::duplicate_field(
3474										"subjectOf",
3475									));
3476								}
3477								r#subject_of_property = Some({
3478									struct DeserializeWith(Vec<SubjectOfProperty>);
3479									impl<'de> Deserialize<'de> for DeserializeWith {
3480										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3481										where
3482											D: Deserializer<'de>,
3483										{
3484											Ok(DeserializeWith(serde_with::As::<
3485												serde_with::OneOrMany<serde_with::Same>,
3486											>::deserialize(deserializer)?))
3487										}
3488									}
3489									match map.next_value::<DeserializeWith>() {
3490										Ok(deserialize_with) => deserialize_with.0,
3491										Err(err) => {
3492											return Err(err);
3493										}
3494									}
3495								});
3496							}
3497							Field::Url => {
3498								if r#url_property.is_some() {
3499									return Err(<A::Error as de::Error>::duplicate_field("url"));
3500								}
3501								r#url_property = Some({
3502									struct DeserializeWith(Vec<UrlProperty>);
3503									impl<'de> Deserialize<'de> for DeserializeWith {
3504										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3505										where
3506											D: Deserializer<'de>,
3507										{
3508											Ok(DeserializeWith(serde_with::As::<
3509												serde_with::OneOrMany<serde_with::Same>,
3510											>::deserialize(deserializer)?))
3511										}
3512									}
3513									match map.next_value::<DeserializeWith>() {
3514										Ok(deserialize_with) => deserialize_with.0,
3515										Err(err) => {
3516											return Err(err);
3517										}
3518									}
3519								});
3520							}
3521							Field::Ignore => {
3522								let _ = map.next_value::<de::IgnoredAny>()?;
3523							}
3524						}
3525					}
3526					Ok(Place {
3527						r#additional_property: r#additional_property_property.unwrap_or_default(),
3528						r#address: r#address_property.unwrap_or_default(),
3529						r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
3530						r#amenity_feature: r#amenity_feature_property.unwrap_or_default(),
3531						r#branch_code: r#branch_code_property.unwrap_or_default(),
3532						r#contained_in: r#contained_in_property.unwrap_or_default(),
3533						r#contained_in_place: r#contained_in_place_property.unwrap_or_default(),
3534						r#contains_place: r#contains_place_property.unwrap_or_default(),
3535						r#event: r#event_property.unwrap_or_default(),
3536						r#events: r#events_property.unwrap_or_default(),
3537						r#fax_number: r#fax_number_property.unwrap_or_default(),
3538						r#geo: r#geo_property.unwrap_or_default(),
3539						r#geo_contains: r#geo_contains_property.unwrap_or_default(),
3540						r#geo_covered_by: r#geo_covered_by_property.unwrap_or_default(),
3541						r#geo_covers: r#geo_covers_property.unwrap_or_default(),
3542						r#geo_crosses: r#geo_crosses_property.unwrap_or_default(),
3543						r#geo_disjoint: r#geo_disjoint_property.unwrap_or_default(),
3544						r#geo_equals: r#geo_equals_property.unwrap_or_default(),
3545						r#geo_intersects: r#geo_intersects_property.unwrap_or_default(),
3546						r#geo_overlaps: r#geo_overlaps_property.unwrap_or_default(),
3547						r#geo_touches: r#geo_touches_property.unwrap_or_default(),
3548						r#geo_within: r#geo_within_property.unwrap_or_default(),
3549						r#global_location_number: r#global_location_number_property
3550							.unwrap_or_default(),
3551						r#has_drive_through_service: r#has_drive_through_service_property
3552							.unwrap_or_default(),
3553						r#has_map: r#has_map_property.unwrap_or_default(),
3554						r#is_accessible_for_free: r#is_accessible_for_free_property
3555							.unwrap_or_default(),
3556						r#isic_v_4: r#isic_v_4_property.unwrap_or_default(),
3557						r#keywords: r#keywords_property.unwrap_or_default(),
3558						r#latitude: r#latitude_property.unwrap_or_default(),
3559						r#logo: r#logo_property.unwrap_or_default(),
3560						r#longitude: r#longitude_property.unwrap_or_default(),
3561						r#map: r#map_property.unwrap_or_default(),
3562						r#maps: r#maps_property.unwrap_or_default(),
3563						r#maximum_attendee_capacity: r#maximum_attendee_capacity_property
3564							.unwrap_or_default(),
3565						r#opening_hours_specification: r#opening_hours_specification_property
3566							.unwrap_or_default(),
3567						r#photo: r#photo_property.unwrap_or_default(),
3568						r#photos: r#photos_property.unwrap_or_default(),
3569						r#public_access: r#public_access_property.unwrap_or_default(),
3570						r#review: r#review_property.unwrap_or_default(),
3571						r#reviews: r#reviews_property.unwrap_or_default(),
3572						r#slogan: r#slogan_property.unwrap_or_default(),
3573						r#smoking_allowed: r#smoking_allowed_property.unwrap_or_default(),
3574						r#special_opening_hours_specification:
3575							r#special_opening_hours_specification_property.unwrap_or_default(),
3576						r#telephone: r#telephone_property.unwrap_or_default(),
3577						r#tour_booking_page: r#tour_booking_page_property.unwrap_or_default(),
3578						r#additional_type: r#additional_type_property.unwrap_or_default(),
3579						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
3580						r#description: r#description_property.unwrap_or_default(),
3581						r#disambiguating_description: r#disambiguating_description_property
3582							.unwrap_or_default(),
3583						r#identifier: r#identifier_property.unwrap_or_default(),
3584						r#image: r#image_property.unwrap_or_default(),
3585						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
3586						r#name: r#name_property.unwrap_or_default(),
3587						r#potential_action: r#potential_action_property.unwrap_or_default(),
3588						r#same_as: r#same_as_property.unwrap_or_default(),
3589						r#subject_of: r#subject_of_property.unwrap_or_default(),
3590						r#url: r#url_property.unwrap_or_default(),
3591					})
3592				}
3593			}
3594			const FIELDS: &[&str] = &[
3595				"additionalProperty",
3596				"address",
3597				"aggregateRating",
3598				"amenityFeature",
3599				"branchCode",
3600				"containedIn",
3601				"containedInPlace",
3602				"containsPlace",
3603				"event",
3604				"events",
3605				"faxNumber",
3606				"geo",
3607				"geoContains",
3608				"geoCoveredBy",
3609				"geoCovers",
3610				"geoCrosses",
3611				"geoDisjoint",
3612				"geoEquals",
3613				"geoIntersects",
3614				"geoOverlaps",
3615				"geoTouches",
3616				"geoWithin",
3617				"globalLocationNumber",
3618				"hasDriveThroughService",
3619				"hasMap",
3620				"isAccessibleForFree",
3621				"isicV4",
3622				"keywords",
3623				"latitude",
3624				"logo",
3625				"longitude",
3626				"map",
3627				"maps",
3628				"maximumAttendeeCapacity",
3629				"openingHoursSpecification",
3630				"photo",
3631				"photos",
3632				"publicAccess",
3633				"review",
3634				"reviews",
3635				"slogan",
3636				"smokingAllowed",
3637				"specialOpeningHoursSpecification",
3638				"telephone",
3639				"tourBookingPage",
3640				"additionalType",
3641				"alternateName",
3642				"description",
3643				"disambiguatingDescription",
3644				"identifier",
3645				"image",
3646				"mainEntityOfPage",
3647				"name",
3648				"potentialAction",
3649				"sameAs",
3650				"subjectOf",
3651				"url",
3652			];
3653			deserializer.deserialize_struct("Place", FIELDS, ClassVisitor)
3654		}
3655	}
3656}
schema_org_types/schemas/classes/place.rs

schema_org_types/schemas/classes/
place.rs
