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