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