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