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