schema_org_types/schemas/classes/
ice_cream_shop.rs

1use super::*;
2/// <https://schema.org/IceCreamShop>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct IceCreamShop {
6	/// <https://schema.org/acceptsReservations>
7	pub r#accepts_reservations: Vec<AcceptsReservationsProperty>,
8	/// <https://schema.org/hasMenu>
9	pub r#has_menu: Vec<HasMenuProperty>,
10	/// <https://schema.org/menu>
11	#[deprecated = "This schema is superseded by <https://schema.org/hasMenu>."]
12	pub r#menu: Vec<MenuProperty>,
13	/// <https://schema.org/servesCuisine>
14	pub r#serves_cuisine: Vec<ServesCuisineProperty>,
15	/// <https://schema.org/starRating>
16	pub r#star_rating: Vec<StarRatingProperty>,
17	/// <https://schema.org/branchOf>
18	#[deprecated = "This schema is superseded by <https://schema.org/parentOrganization>."]
19	pub r#branch_of: Vec<BranchOfProperty>,
20	/// <https://schema.org/currenciesAccepted>
21	pub r#currencies_accepted: Vec<CurrenciesAcceptedProperty>,
22	/// <https://schema.org/openingHours>
23	pub r#opening_hours: Vec<OpeningHoursProperty>,
24	/// <https://schema.org/paymentAccepted>
25	pub r#payment_accepted: Vec<PaymentAcceptedProperty>,
26	/// <https://schema.org/priceRange>
27	pub r#price_range: Vec<PriceRangeProperty>,
28	/// <https://schema.org/actionableFeedbackPolicy>
29	pub r#actionable_feedback_policy: Vec<ActionableFeedbackPolicyProperty>,
30	/// <https://schema.org/address>
31	pub r#address: Vec<AddressProperty>,
32	/// <https://schema.org/agentInteractionStatistic>
33	pub r#agent_interaction_statistic: Vec<AgentInteractionStatisticProperty>,
34	/// <https://schema.org/aggregateRating>
35	pub r#aggregate_rating: Vec<AggregateRatingProperty>,
36	/// <https://schema.org/alumni>
37	pub r#alumni: Vec<AlumniProperty>,
38	/// <https://schema.org/areaServed>
39	pub r#area_served: Vec<AreaServedProperty>,
40	/// <https://schema.org/award>
41	pub r#award: Vec<AwardProperty>,
42	/// <https://schema.org/awards>
43	#[deprecated = "This schema is superseded by <https://schema.org/award>."]
44	pub r#awards: Vec<AwardsProperty>,
45	/// <https://schema.org/brand>
46	pub r#brand: Vec<BrandProperty>,
47	/// <https://schema.org/contactPoint>
48	pub r#contact_point: Vec<ContactPointProperty>,
49	/// <https://schema.org/contactPoints>
50	#[deprecated = "This schema is superseded by <https://schema.org/contactPoint>."]
51	pub r#contact_points: Vec<ContactPointsProperty>,
52	/// <https://schema.org/correctionsPolicy>
53	pub r#corrections_policy: Vec<CorrectionsPolicyProperty>,
54	/// <https://schema.org/department>
55	pub r#department: Vec<DepartmentProperty>,
56	/// <https://schema.org/dissolutionDate>
57	pub r#dissolution_date: Vec<DissolutionDateProperty>,
58	/// <https://schema.org/diversityPolicy>
59	pub r#diversity_policy: Vec<DiversityPolicyProperty>,
60	/// <https://schema.org/diversityStaffingReport>
61	pub r#diversity_staffing_report: Vec<DiversityStaffingReportProperty>,
62	/// <https://schema.org/duns>
63	pub r#duns: Vec<DunsProperty>,
64	/// <https://schema.org/email>
65	pub r#email: Vec<EmailProperty>,
66	/// <https://schema.org/employee>
67	pub r#employee: Vec<EmployeeProperty>,
68	/// <https://schema.org/employees>
69	#[deprecated = "This schema is superseded by <https://schema.org/employee>."]
70	pub r#employees: Vec<EmployeesProperty>,
71	/// <https://schema.org/ethicsPolicy>
72	pub r#ethics_policy: Vec<EthicsPolicyProperty>,
73	/// <https://schema.org/event>
74	pub r#event: Vec<EventProperty>,
75	/// <https://schema.org/events>
76	#[deprecated = "This schema is superseded by <https://schema.org/event>."]
77	pub r#events: Vec<EventsProperty>,
78	/// <https://schema.org/faxNumber>
79	pub r#fax_number: Vec<FaxNumberProperty>,
80	/// <https://schema.org/founder>
81	pub r#founder: Vec<FounderProperty>,
82	/// <https://schema.org/founders>
83	#[deprecated = "This schema is superseded by <https://schema.org/founder>."]
84	pub r#founders: Vec<FoundersProperty>,
85	/// <https://schema.org/foundingDate>
86	pub r#founding_date: Vec<FoundingDateProperty>,
87	/// <https://schema.org/foundingLocation>
88	pub r#founding_location: Vec<FoundingLocationProperty>,
89	/// <https://schema.org/funder>
90	pub r#funder: Vec<FunderProperty>,
91	/// <https://schema.org/funding>
92	pub r#funding: Vec<FundingProperty>,
93	/// <https://schema.org/globalLocationNumber>
94	pub r#global_location_number: Vec<GlobalLocationNumberProperty>,
95	/// <https://schema.org/hasCredential>
96	pub r#has_credential: Vec<HasCredentialProperty>,
97	/// <https://schema.org/hasMerchantReturnPolicy>
98	pub r#has_merchant_return_policy: Vec<HasMerchantReturnPolicyProperty>,
99	/// <https://schema.org/hasOfferCatalog>
100	pub r#has_offer_catalog: Vec<HasOfferCatalogProperty>,
101	/// <https://schema.org/hasPOS>
102	pub r#has_pos: Vec<HasPosProperty>,
103	/// <https://schema.org/hasProductReturnPolicy>
104	#[deprecated = "This schema is archived, see <https://schema.org/docs/attic.home.html>. This schema is superseded by <https://schema.org/hasMerchantReturnPolicy>."]
105	pub r#has_product_return_policy: Vec<HasProductReturnPolicyProperty>,
106	/// <https://schema.org/interactionStatistic>
107	pub r#interaction_statistic: Vec<InteractionStatisticProperty>,
108	/// <https://schema.org/isicV4>
109	pub r#isic_v_4: Vec<IsicV4Property>,
110	/// <https://schema.org/iso6523Code>
111	pub r#iso_6523_code: Vec<Iso6523CodeProperty>,
112	/// <https://schema.org/keywords>
113	pub r#keywords: Vec<KeywordsProperty>,
114	/// <https://schema.org/knowsAbout>
115	pub r#knows_about: Vec<KnowsAboutProperty>,
116	/// <https://schema.org/knowsLanguage>
117	pub r#knows_language: Vec<KnowsLanguageProperty>,
118	/// <https://schema.org/legalName>
119	pub r#legal_name: Vec<LegalNameProperty>,
120	/// <https://schema.org/leiCode>
121	pub r#lei_code: Vec<LeiCodeProperty>,
122	/// <https://schema.org/location>
123	pub r#location: Vec<LocationProperty>,
124	/// <https://schema.org/logo>
125	pub r#logo: Vec<LogoProperty>,
126	/// <https://schema.org/makesOffer>
127	pub r#makes_offer: Vec<MakesOfferProperty>,
128	/// <https://schema.org/member>
129	pub r#member: Vec<MemberProperty>,
130	/// <https://schema.org/memberOf>
131	pub r#member_of: Vec<MemberOfProperty>,
132	/// <https://schema.org/members>
133	#[deprecated = "This schema is superseded by <https://schema.org/member>."]
134	pub r#members: Vec<MembersProperty>,
135	/// <https://schema.org/naics>
136	pub r#naics: Vec<NaicsProperty>,
137	/// <https://schema.org/nonprofitStatus>
138	pub r#nonprofit_status: Vec<NonprofitStatusProperty>,
139	/// <https://schema.org/numberOfEmployees>
140	pub r#number_of_employees: Vec<NumberOfEmployeesProperty>,
141	/// <https://schema.org/ownershipFundingInfo>
142	pub r#ownership_funding_info: Vec<OwnershipFundingInfoProperty>,
143	/// <https://schema.org/owns>
144	pub r#owns: Vec<OwnsProperty>,
145	/// <https://schema.org/parentOrganization>
146	pub r#parent_organization: Vec<ParentOrganizationProperty>,
147	/// <https://schema.org/publishingPrinciples>
148	pub r#publishing_principles: Vec<PublishingPrinciplesProperty>,
149	/// <https://schema.org/review>
150	pub r#review: Vec<ReviewProperty>,
151	/// <https://schema.org/reviews>
152	#[deprecated = "This schema is superseded by <https://schema.org/review>."]
153	pub r#reviews: Vec<ReviewsProperty>,
154	/// <https://schema.org/seeks>
155	pub r#seeks: Vec<SeeksProperty>,
156	/// <https://schema.org/serviceArea>
157	#[deprecated = "This schema is superseded by <https://schema.org/areaServed>."]
158	pub r#service_area: Vec<ServiceAreaProperty>,
159	/// <https://schema.org/slogan>
160	pub r#slogan: Vec<SloganProperty>,
161	/// <https://schema.org/sponsor>
162	pub r#sponsor: Vec<SponsorProperty>,
163	/// <https://schema.org/subOrganization>
164	pub r#sub_organization: Vec<SubOrganizationProperty>,
165	/// <https://schema.org/taxID>
166	pub r#tax_id: Vec<TaxIdProperty>,
167	/// <https://schema.org/telephone>
168	pub r#telephone: Vec<TelephoneProperty>,
169	/// <https://schema.org/unnamedSourcesPolicy>
170	pub r#unnamed_sources_policy: Vec<UnnamedSourcesPolicyProperty>,
171	/// <https://schema.org/vatID>
172	pub r#vat_id: Vec<VatIdProperty>,
173	/// <https://schema.org/additionalProperty>
174	pub r#additional_property: Vec<AdditionalPropertyProperty>,
175	/// <https://schema.org/amenityFeature>
176	pub r#amenity_feature: Vec<AmenityFeatureProperty>,
177	/// <https://schema.org/branchCode>
178	pub r#branch_code: Vec<BranchCodeProperty>,
179	/// <https://schema.org/containedIn>
180	#[deprecated = "This schema is superseded by <https://schema.org/containedInPlace>."]
181	pub r#contained_in: Vec<ContainedInProperty>,
182	/// <https://schema.org/containedInPlace>
183	pub r#contained_in_place: Vec<ContainedInPlaceProperty>,
184	/// <https://schema.org/containsPlace>
185	pub r#contains_place: Vec<ContainsPlaceProperty>,
186	/// <https://schema.org/geo>
187	pub r#geo: Vec<GeoProperty>,
188	/// <https://schema.org/geoContains>
189	pub r#geo_contains: Vec<GeoContainsProperty>,
190	/// <https://schema.org/geoCoveredBy>
191	pub r#geo_covered_by: Vec<GeoCoveredByProperty>,
192	/// <https://schema.org/geoCovers>
193	pub r#geo_covers: Vec<GeoCoversProperty>,
194	/// <https://schema.org/geoCrosses>
195	pub r#geo_crosses: Vec<GeoCrossesProperty>,
196	/// <https://schema.org/geoDisjoint>
197	pub r#geo_disjoint: Vec<GeoDisjointProperty>,
198	/// <https://schema.org/geoEquals>
199	pub r#geo_equals: Vec<GeoEqualsProperty>,
200	/// <https://schema.org/geoIntersects>
201	pub r#geo_intersects: Vec<GeoIntersectsProperty>,
202	/// <https://schema.org/geoOverlaps>
203	pub r#geo_overlaps: Vec<GeoOverlapsProperty>,
204	/// <https://schema.org/geoTouches>
205	pub r#geo_touches: Vec<GeoTouchesProperty>,
206	/// <https://schema.org/geoWithin>
207	pub r#geo_within: Vec<GeoWithinProperty>,
208	/// <https://schema.org/hasDriveThroughService>
209	pub r#has_drive_through_service: Vec<HasDriveThroughServiceProperty>,
210	/// <https://schema.org/hasMap>
211	pub r#has_map: Vec<HasMapProperty>,
212	/// <https://schema.org/isAccessibleForFree>
213	pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
214	/// <https://schema.org/latitude>
215	pub r#latitude: Vec<LatitudeProperty>,
216	/// <https://schema.org/longitude>
217	pub r#longitude: Vec<LongitudeProperty>,
218	/// <https://schema.org/map>
219	#[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
220	pub r#map: Vec<MapProperty>,
221	/// <https://schema.org/maps>
222	#[deprecated = "This schema is superseded by <https://schema.org/hasMap>."]
223	pub r#maps: Vec<MapsProperty>,
224	/// <https://schema.org/maximumAttendeeCapacity>
225	pub r#maximum_attendee_capacity: Vec<MaximumAttendeeCapacityProperty>,
226	/// <https://schema.org/openingHoursSpecification>
227	pub r#opening_hours_specification: Vec<OpeningHoursSpecificationProperty>,
228	/// <https://schema.org/photo>
229	pub r#photo: Vec<PhotoProperty>,
230	/// <https://schema.org/photos>
231	#[deprecated = "This schema is superseded by <https://schema.org/photo>."]
232	pub r#photos: Vec<PhotosProperty>,
233	/// <https://schema.org/publicAccess>
234	pub r#public_access: Vec<PublicAccessProperty>,
235	/// <https://schema.org/smokingAllowed>
236	pub r#smoking_allowed: Vec<SmokingAllowedProperty>,
237	/// <https://schema.org/specialOpeningHoursSpecification>
238	pub r#special_opening_hours_specification: Vec<SpecialOpeningHoursSpecificationProperty>,
239	/// <https://schema.org/tourBookingPage>
240	pub r#tour_booking_page: Vec<TourBookingPageProperty>,
241	/// <https://schema.org/additionalType>
242	pub r#additional_type: Vec<AdditionalTypeProperty>,
243	/// <https://schema.org/alternateName>
244	pub r#alternate_name: Vec<AlternateNameProperty>,
245	/// <https://schema.org/description>
246	pub r#description: Vec<DescriptionProperty>,
247	/// <https://schema.org/disambiguatingDescription>
248	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
249	/// <https://schema.org/identifier>
250	pub r#identifier: Vec<IdentifierProperty>,
251	/// <https://schema.org/image>
252	pub r#image: Vec<ImageProperty>,
253	/// <https://schema.org/mainEntityOfPage>
254	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
255	/// <https://schema.org/name>
256	pub r#name: Vec<NameProperty>,
257	/// <https://schema.org/potentialAction>
258	pub r#potential_action: Vec<PotentialActionProperty>,
259	/// <https://schema.org/sameAs>
260	pub r#same_as: Vec<SameAsProperty>,
261	/// <https://schema.org/subjectOf>
262	pub r#subject_of: Vec<SubjectOfProperty>,
263	/// <https://schema.org/url>
264	pub r#url: Vec<UrlProperty>,
265}
266/// This trait is for properties from <https://schema.org/IceCreamShop>.
267pub trait IceCreamShopTrait {}
268impl IceCreamShopTrait for IceCreamShop {}
269impl FoodEstablishmentTrait for IceCreamShop {
270	fn get_accepts_reservations(&self) -> &[AcceptsReservationsProperty] {
271		self.r#accepts_reservations.as_slice()
272	}
273	fn take_accepts_reservations(&mut self) -> Vec<AcceptsReservationsProperty> {
274		std::mem::take(&mut self.r#accepts_reservations)
275	}
276	fn get_has_menu(&self) -> &[HasMenuProperty] {
277		self.r#has_menu.as_slice()
278	}
279	fn take_has_menu(&mut self) -> Vec<HasMenuProperty> {
280		std::mem::take(&mut self.r#has_menu)
281	}
282	fn get_menu(&self) -> &[MenuProperty] {
283		self.r#menu.as_slice()
284	}
285	fn take_menu(&mut self) -> Vec<MenuProperty> {
286		std::mem::take(&mut self.r#menu)
287	}
288	fn get_serves_cuisine(&self) -> &[ServesCuisineProperty] {
289		self.r#serves_cuisine.as_slice()
290	}
291	fn take_serves_cuisine(&mut self) -> Vec<ServesCuisineProperty> {
292		std::mem::take(&mut self.r#serves_cuisine)
293	}
294	fn get_star_rating(&self) -> &[StarRatingProperty] {
295		self.r#star_rating.as_slice()
296	}
297	fn take_star_rating(&mut self) -> Vec<StarRatingProperty> {
298		std::mem::take(&mut self.r#star_rating)
299	}
300}
301impl LocalBusinessTrait for IceCreamShop {
302	fn get_branch_of(&self) -> &[BranchOfProperty] {
303		self.r#branch_of.as_slice()
304	}
305	fn take_branch_of(&mut self) -> Vec<BranchOfProperty> {
306		std::mem::take(&mut self.r#branch_of)
307	}
308	fn get_currencies_accepted(&self) -> &[CurrenciesAcceptedProperty] {
309		self.r#currencies_accepted.as_slice()
310	}
311	fn take_currencies_accepted(&mut self) -> Vec<CurrenciesAcceptedProperty> {
312		std::mem::take(&mut self.r#currencies_accepted)
313	}
314	fn get_opening_hours(&self) -> &[OpeningHoursProperty] {
315		self.r#opening_hours.as_slice()
316	}
317	fn take_opening_hours(&mut self) -> Vec<OpeningHoursProperty> {
318		std::mem::take(&mut self.r#opening_hours)
319	}
320	fn get_payment_accepted(&self) -> &[PaymentAcceptedProperty] {
321		self.r#payment_accepted.as_slice()
322	}
323	fn take_payment_accepted(&mut self) -> Vec<PaymentAcceptedProperty> {
324		std::mem::take(&mut self.r#payment_accepted)
325	}
326	fn get_price_range(&self) -> &[PriceRangeProperty] {
327		self.r#price_range.as_slice()
328	}
329	fn take_price_range(&mut self) -> Vec<PriceRangeProperty> {
330		std::mem::take(&mut self.r#price_range)
331	}
332}
333impl OrganizationTrait for IceCreamShop {
334	fn get_actionable_feedback_policy(&self) -> &[ActionableFeedbackPolicyProperty] {
335		self.r#actionable_feedback_policy.as_slice()
336	}
337	fn take_actionable_feedback_policy(&mut self) -> Vec<ActionableFeedbackPolicyProperty> {
338		std::mem::take(&mut self.r#actionable_feedback_policy)
339	}
340	fn get_address(&self) -> &[AddressProperty] {
341		self.r#address.as_slice()
342	}
343	fn take_address(&mut self) -> Vec<AddressProperty> {
344		std::mem::take(&mut self.r#address)
345	}
346	fn get_agent_interaction_statistic(&self) -> &[AgentInteractionStatisticProperty] {
347		self.r#agent_interaction_statistic.as_slice()
348	}
349	fn take_agent_interaction_statistic(&mut self) -> Vec<AgentInteractionStatisticProperty> {
350		std::mem::take(&mut self.r#agent_interaction_statistic)
351	}
352	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
353		self.r#aggregate_rating.as_slice()
354	}
355	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
356		std::mem::take(&mut self.r#aggregate_rating)
357	}
358	fn get_alumni(&self) -> &[AlumniProperty] {
359		self.r#alumni.as_slice()
360	}
361	fn take_alumni(&mut self) -> Vec<AlumniProperty> {
362		std::mem::take(&mut self.r#alumni)
363	}
364	fn get_area_served(&self) -> &[AreaServedProperty] {
365		self.r#area_served.as_slice()
366	}
367	fn take_area_served(&mut self) -> Vec<AreaServedProperty> {
368		std::mem::take(&mut self.r#area_served)
369	}
370	fn get_award(&self) -> &[AwardProperty] {
371		self.r#award.as_slice()
372	}
373	fn take_award(&mut self) -> Vec<AwardProperty> {
374		std::mem::take(&mut self.r#award)
375	}
376	fn get_awards(&self) -> &[AwardsProperty] {
377		self.r#awards.as_slice()
378	}
379	fn take_awards(&mut self) -> Vec<AwardsProperty> {
380		std::mem::take(&mut self.r#awards)
381	}
382	fn get_brand(&self) -> &[BrandProperty] {
383		self.r#brand.as_slice()
384	}
385	fn take_brand(&mut self) -> Vec<BrandProperty> {
386		std::mem::take(&mut self.r#brand)
387	}
388	fn get_contact_point(&self) -> &[ContactPointProperty] {
389		self.r#contact_point.as_slice()
390	}
391	fn take_contact_point(&mut self) -> Vec<ContactPointProperty> {
392		std::mem::take(&mut self.r#contact_point)
393	}
394	fn get_contact_points(&self) -> &[ContactPointsProperty] {
395		self.r#contact_points.as_slice()
396	}
397	fn take_contact_points(&mut self) -> Vec<ContactPointsProperty> {
398		std::mem::take(&mut self.r#contact_points)
399	}
400	fn get_corrections_policy(&self) -> &[CorrectionsPolicyProperty] {
401		self.r#corrections_policy.as_slice()
402	}
403	fn take_corrections_policy(&mut self) -> Vec<CorrectionsPolicyProperty> {
404		std::mem::take(&mut self.r#corrections_policy)
405	}
406	fn get_department(&self) -> &[DepartmentProperty] {
407		self.r#department.as_slice()
408	}
409	fn take_department(&mut self) -> Vec<DepartmentProperty> {
410		std::mem::take(&mut self.r#department)
411	}
412	fn get_dissolution_date(&self) -> &[DissolutionDateProperty] {
413		self.r#dissolution_date.as_slice()
414	}
415	fn take_dissolution_date(&mut self) -> Vec<DissolutionDateProperty> {
416		std::mem::take(&mut self.r#dissolution_date)
417	}
418	fn get_diversity_policy(&self) -> &[DiversityPolicyProperty] {
419		self.r#diversity_policy.as_slice()
420	}
421	fn take_diversity_policy(&mut self) -> Vec<DiversityPolicyProperty> {
422		std::mem::take(&mut self.r#diversity_policy)
423	}
424	fn get_diversity_staffing_report(&self) -> &[DiversityStaffingReportProperty] {
425		self.r#diversity_staffing_report.as_slice()
426	}
427	fn take_diversity_staffing_report(&mut self) -> Vec<DiversityStaffingReportProperty> {
428		std::mem::take(&mut self.r#diversity_staffing_report)
429	}
430	fn get_duns(&self) -> &[DunsProperty] {
431		self.r#duns.as_slice()
432	}
433	fn take_duns(&mut self) -> Vec<DunsProperty> {
434		std::mem::take(&mut self.r#duns)
435	}
436	fn get_email(&self) -> &[EmailProperty] {
437		self.r#email.as_slice()
438	}
439	fn take_email(&mut self) -> Vec<EmailProperty> {
440		std::mem::take(&mut self.r#email)
441	}
442	fn get_employee(&self) -> &[EmployeeProperty] {
443		self.r#employee.as_slice()
444	}
445	fn take_employee(&mut self) -> Vec<EmployeeProperty> {
446		std::mem::take(&mut self.r#employee)
447	}
448	fn get_employees(&self) -> &[EmployeesProperty] {
449		self.r#employees.as_slice()
450	}
451	fn take_employees(&mut self) -> Vec<EmployeesProperty> {
452		std::mem::take(&mut self.r#employees)
453	}
454	fn get_ethics_policy(&self) -> &[EthicsPolicyProperty] {
455		self.r#ethics_policy.as_slice()
456	}
457	fn take_ethics_policy(&mut self) -> Vec<EthicsPolicyProperty> {
458		std::mem::take(&mut self.r#ethics_policy)
459	}
460	fn get_event(&self) -> &[EventProperty] {
461		self.r#event.as_slice()
462	}
463	fn take_event(&mut self) -> Vec<EventProperty> {
464		std::mem::take(&mut self.r#event)
465	}
466	fn get_events(&self) -> &[EventsProperty] {
467		self.r#events.as_slice()
468	}
469	fn take_events(&mut self) -> Vec<EventsProperty> {
470		std::mem::take(&mut self.r#events)
471	}
472	fn get_fax_number(&self) -> &[FaxNumberProperty] {
473		self.r#fax_number.as_slice()
474	}
475	fn take_fax_number(&mut self) -> Vec<FaxNumberProperty> {
476		std::mem::take(&mut self.r#fax_number)
477	}
478	fn get_founder(&self) -> &[FounderProperty] {
479		self.r#founder.as_slice()
480	}
481	fn take_founder(&mut self) -> Vec<FounderProperty> {
482		std::mem::take(&mut self.r#founder)
483	}
484	fn get_founders(&self) -> &[FoundersProperty] {
485		self.r#founders.as_slice()
486	}
487	fn take_founders(&mut self) -> Vec<FoundersProperty> {
488		std::mem::take(&mut self.r#founders)
489	}
490	fn get_founding_date(&self) -> &[FoundingDateProperty] {
491		self.r#founding_date.as_slice()
492	}
493	fn take_founding_date(&mut self) -> Vec<FoundingDateProperty> {
494		std::mem::take(&mut self.r#founding_date)
495	}
496	fn get_founding_location(&self) -> &[FoundingLocationProperty] {
497		self.r#founding_location.as_slice()
498	}
499	fn take_founding_location(&mut self) -> Vec<FoundingLocationProperty> {
500		std::mem::take(&mut self.r#founding_location)
501	}
502	fn get_funder(&self) -> &[FunderProperty] {
503		self.r#funder.as_slice()
504	}
505	fn take_funder(&mut self) -> Vec<FunderProperty> {
506		std::mem::take(&mut self.r#funder)
507	}
508	fn get_funding(&self) -> &[FundingProperty] {
509		self.r#funding.as_slice()
510	}
511	fn take_funding(&mut self) -> Vec<FundingProperty> {
512		std::mem::take(&mut self.r#funding)
513	}
514	fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty] {
515		self.r#global_location_number.as_slice()
516	}
517	fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty> {
518		std::mem::take(&mut self.r#global_location_number)
519	}
520	fn get_has_credential(&self) -> &[HasCredentialProperty] {
521		self.r#has_credential.as_slice()
522	}
523	fn take_has_credential(&mut self) -> Vec<HasCredentialProperty> {
524		std::mem::take(&mut self.r#has_credential)
525	}
526	fn get_has_merchant_return_policy(&self) -> &[HasMerchantReturnPolicyProperty] {
527		self.r#has_merchant_return_policy.as_slice()
528	}
529	fn take_has_merchant_return_policy(&mut self) -> Vec<HasMerchantReturnPolicyProperty> {
530		std::mem::take(&mut self.r#has_merchant_return_policy)
531	}
532	fn get_has_offer_catalog(&self) -> &[HasOfferCatalogProperty] {
533		self.r#has_offer_catalog.as_slice()
534	}
535	fn take_has_offer_catalog(&mut self) -> Vec<HasOfferCatalogProperty> {
536		std::mem::take(&mut self.r#has_offer_catalog)
537	}
538	fn get_has_pos(&self) -> &[HasPosProperty] {
539		self.r#has_pos.as_slice()
540	}
541	fn take_has_pos(&mut self) -> Vec<HasPosProperty> {
542		std::mem::take(&mut self.r#has_pos)
543	}
544	fn get_has_product_return_policy(&self) -> &[HasProductReturnPolicyProperty] {
545		self.r#has_product_return_policy.as_slice()
546	}
547	fn take_has_product_return_policy(&mut self) -> Vec<HasProductReturnPolicyProperty> {
548		std::mem::take(&mut self.r#has_product_return_policy)
549	}
550	fn get_interaction_statistic(&self) -> &[InteractionStatisticProperty] {
551		self.r#interaction_statistic.as_slice()
552	}
553	fn take_interaction_statistic(&mut self) -> Vec<InteractionStatisticProperty> {
554		std::mem::take(&mut self.r#interaction_statistic)
555	}
556	fn get_isic_v_4(&self) -> &[IsicV4Property] {
557		self.r#isic_v_4.as_slice()
558	}
559	fn take_isic_v_4(&mut self) -> Vec<IsicV4Property> {
560		std::mem::take(&mut self.r#isic_v_4)
561	}
562	fn get_iso_6523_code(&self) -> &[Iso6523CodeProperty] {
563		self.r#iso_6523_code.as_slice()
564	}
565	fn take_iso_6523_code(&mut self) -> Vec<Iso6523CodeProperty> {
566		std::mem::take(&mut self.r#iso_6523_code)
567	}
568	fn get_keywords(&self) -> &[KeywordsProperty] {
569		self.r#keywords.as_slice()
570	}
571	fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
572		std::mem::take(&mut self.r#keywords)
573	}
574	fn get_knows_about(&self) -> &[KnowsAboutProperty] {
575		self.r#knows_about.as_slice()
576	}
577	fn take_knows_about(&mut self) -> Vec<KnowsAboutProperty> {
578		std::mem::take(&mut self.r#knows_about)
579	}
580	fn get_knows_language(&self) -> &[KnowsLanguageProperty] {
581		self.r#knows_language.as_slice()
582	}
583	fn take_knows_language(&mut self) -> Vec<KnowsLanguageProperty> {
584		std::mem::take(&mut self.r#knows_language)
585	}
586	fn get_legal_name(&self) -> &[LegalNameProperty] {
587		self.r#legal_name.as_slice()
588	}
589	fn take_legal_name(&mut self) -> Vec<LegalNameProperty> {
590		std::mem::take(&mut self.r#legal_name)
591	}
592	fn get_lei_code(&self) -> &[LeiCodeProperty] {
593		self.r#lei_code.as_slice()
594	}
595	fn take_lei_code(&mut self) -> Vec<LeiCodeProperty> {
596		std::mem::take(&mut self.r#lei_code)
597	}
598	fn get_location(&self) -> &[LocationProperty] {
599		self.r#location.as_slice()
600	}
601	fn take_location(&mut self) -> Vec<LocationProperty> {
602		std::mem::take(&mut self.r#location)
603	}
604	fn get_logo(&self) -> &[LogoProperty] {
605		self.r#logo.as_slice()
606	}
607	fn take_logo(&mut self) -> Vec<LogoProperty> {
608		std::mem::take(&mut self.r#logo)
609	}
610	fn get_makes_offer(&self) -> &[MakesOfferProperty] {
611		self.r#makes_offer.as_slice()
612	}
613	fn take_makes_offer(&mut self) -> Vec<MakesOfferProperty> {
614		std::mem::take(&mut self.r#makes_offer)
615	}
616	fn get_member(&self) -> &[MemberProperty] {
617		self.r#member.as_slice()
618	}
619	fn take_member(&mut self) -> Vec<MemberProperty> {
620		std::mem::take(&mut self.r#member)
621	}
622	fn get_member_of(&self) -> &[MemberOfProperty] {
623		self.r#member_of.as_slice()
624	}
625	fn take_member_of(&mut self) -> Vec<MemberOfProperty> {
626		std::mem::take(&mut self.r#member_of)
627	}
628	fn get_members(&self) -> &[MembersProperty] {
629		self.r#members.as_slice()
630	}
631	fn take_members(&mut self) -> Vec<MembersProperty> {
632		std::mem::take(&mut self.r#members)
633	}
634	fn get_naics(&self) -> &[NaicsProperty] {
635		self.r#naics.as_slice()
636	}
637	fn take_naics(&mut self) -> Vec<NaicsProperty> {
638		std::mem::take(&mut self.r#naics)
639	}
640	fn get_nonprofit_status(&self) -> &[NonprofitStatusProperty] {
641		self.r#nonprofit_status.as_slice()
642	}
643	fn take_nonprofit_status(&mut self) -> Vec<NonprofitStatusProperty> {
644		std::mem::take(&mut self.r#nonprofit_status)
645	}
646	fn get_number_of_employees(&self) -> &[NumberOfEmployeesProperty] {
647		self.r#number_of_employees.as_slice()
648	}
649	fn take_number_of_employees(&mut self) -> Vec<NumberOfEmployeesProperty> {
650		std::mem::take(&mut self.r#number_of_employees)
651	}
652	fn get_ownership_funding_info(&self) -> &[OwnershipFundingInfoProperty] {
653		self.r#ownership_funding_info.as_slice()
654	}
655	fn take_ownership_funding_info(&mut self) -> Vec<OwnershipFundingInfoProperty> {
656		std::mem::take(&mut self.r#ownership_funding_info)
657	}
658	fn get_owns(&self) -> &[OwnsProperty] {
659		self.r#owns.as_slice()
660	}
661	fn take_owns(&mut self) -> Vec<OwnsProperty> {
662		std::mem::take(&mut self.r#owns)
663	}
664	fn get_parent_organization(&self) -> &[ParentOrganizationProperty] {
665		self.r#parent_organization.as_slice()
666	}
667	fn take_parent_organization(&mut self) -> Vec<ParentOrganizationProperty> {
668		std::mem::take(&mut self.r#parent_organization)
669	}
670	fn get_publishing_principles(&self) -> &[PublishingPrinciplesProperty] {
671		self.r#publishing_principles.as_slice()
672	}
673	fn take_publishing_principles(&mut self) -> Vec<PublishingPrinciplesProperty> {
674		std::mem::take(&mut self.r#publishing_principles)
675	}
676	fn get_review(&self) -> &[ReviewProperty] {
677		self.r#review.as_slice()
678	}
679	fn take_review(&mut self) -> Vec<ReviewProperty> {
680		std::mem::take(&mut self.r#review)
681	}
682	fn get_reviews(&self) -> &[ReviewsProperty] {
683		self.r#reviews.as_slice()
684	}
685	fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
686		std::mem::take(&mut self.r#reviews)
687	}
688	fn get_seeks(&self) -> &[SeeksProperty] {
689		self.r#seeks.as_slice()
690	}
691	fn take_seeks(&mut self) -> Vec<SeeksProperty> {
692		std::mem::take(&mut self.r#seeks)
693	}
694	fn get_service_area(&self) -> &[ServiceAreaProperty] {
695		self.r#service_area.as_slice()
696	}
697	fn take_service_area(&mut self) -> Vec<ServiceAreaProperty> {
698		std::mem::take(&mut self.r#service_area)
699	}
700	fn get_slogan(&self) -> &[SloganProperty] {
701		self.r#slogan.as_slice()
702	}
703	fn take_slogan(&mut self) -> Vec<SloganProperty> {
704		std::mem::take(&mut self.r#slogan)
705	}
706	fn get_sponsor(&self) -> &[SponsorProperty] {
707		self.r#sponsor.as_slice()
708	}
709	fn take_sponsor(&mut self) -> Vec<SponsorProperty> {
710		std::mem::take(&mut self.r#sponsor)
711	}
712	fn get_sub_organization(&self) -> &[SubOrganizationProperty] {
713		self.r#sub_organization.as_slice()
714	}
715	fn take_sub_organization(&mut self) -> Vec<SubOrganizationProperty> {
716		std::mem::take(&mut self.r#sub_organization)
717	}
718	fn get_tax_id(&self) -> &[TaxIdProperty] {
719		self.r#tax_id.as_slice()
720	}
721	fn take_tax_id(&mut self) -> Vec<TaxIdProperty> {
722		std::mem::take(&mut self.r#tax_id)
723	}
724	fn get_telephone(&self) -> &[TelephoneProperty] {
725		self.r#telephone.as_slice()
726	}
727	fn take_telephone(&mut self) -> Vec<TelephoneProperty> {
728		std::mem::take(&mut self.r#telephone)
729	}
730	fn get_unnamed_sources_policy(&self) -> &[UnnamedSourcesPolicyProperty] {
731		self.r#unnamed_sources_policy.as_slice()
732	}
733	fn take_unnamed_sources_policy(&mut self) -> Vec<UnnamedSourcesPolicyProperty> {
734		std::mem::take(&mut self.r#unnamed_sources_policy)
735	}
736	fn get_vat_id(&self) -> &[VatIdProperty] {
737		self.r#vat_id.as_slice()
738	}
739	fn take_vat_id(&mut self) -> Vec<VatIdProperty> {
740		std::mem::take(&mut self.r#vat_id)
741	}
742}
743impl PlaceTrait for IceCreamShop {
744	fn get_additional_property(&self) -> &[AdditionalPropertyProperty] {
745		self.r#additional_property.as_slice()
746	}
747	fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty> {
748		std::mem::take(&mut self.r#additional_property)
749	}
750	fn get_address(&self) -> &[AddressProperty] {
751		self.r#address.as_slice()
752	}
753	fn take_address(&mut self) -> Vec<AddressProperty> {
754		std::mem::take(&mut self.r#address)
755	}
756	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
757		self.r#aggregate_rating.as_slice()
758	}
759	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
760		std::mem::take(&mut self.r#aggregate_rating)
761	}
762	fn get_amenity_feature(&self) -> &[AmenityFeatureProperty] {
763		self.r#amenity_feature.as_slice()
764	}
765	fn take_amenity_feature(&mut self) -> Vec<AmenityFeatureProperty> {
766		std::mem::take(&mut self.r#amenity_feature)
767	}
768	fn get_branch_code(&self) -> &[BranchCodeProperty] {
769		self.r#branch_code.as_slice()
770	}
771	fn take_branch_code(&mut self) -> Vec<BranchCodeProperty> {
772		std::mem::take(&mut self.r#branch_code)
773	}
774	fn get_contained_in(&self) -> &[ContainedInProperty] {
775		self.r#contained_in.as_slice()
776	}
777	fn take_contained_in(&mut self) -> Vec<ContainedInProperty> {
778		std::mem::take(&mut self.r#contained_in)
779	}
780	fn get_contained_in_place(&self) -> &[ContainedInPlaceProperty] {
781		self.r#contained_in_place.as_slice()
782	}
783	fn take_contained_in_place(&mut self) -> Vec<ContainedInPlaceProperty> {
784		std::mem::take(&mut self.r#contained_in_place)
785	}
786	fn get_contains_place(&self) -> &[ContainsPlaceProperty] {
787		self.r#contains_place.as_slice()
788	}
789	fn take_contains_place(&mut self) -> Vec<ContainsPlaceProperty> {
790		std::mem::take(&mut self.r#contains_place)
791	}
792	fn get_event(&self) -> &[EventProperty] {
793		self.r#event.as_slice()
794	}
795	fn take_event(&mut self) -> Vec<EventProperty> {
796		std::mem::take(&mut self.r#event)
797	}
798	fn get_events(&self) -> &[EventsProperty] {
799		self.r#events.as_slice()
800	}
801	fn take_events(&mut self) -> Vec<EventsProperty> {
802		std::mem::take(&mut self.r#events)
803	}
804	fn get_fax_number(&self) -> &[FaxNumberProperty] {
805		self.r#fax_number.as_slice()
806	}
807	fn take_fax_number(&mut self) -> Vec<FaxNumberProperty> {
808		std::mem::take(&mut self.r#fax_number)
809	}
810	fn get_geo(&self) -> &[GeoProperty] {
811		self.r#geo.as_slice()
812	}
813	fn take_geo(&mut self) -> Vec<GeoProperty> {
814		std::mem::take(&mut self.r#geo)
815	}
816	fn get_geo_contains(&self) -> &[GeoContainsProperty] {
817		self.r#geo_contains.as_slice()
818	}
819	fn take_geo_contains(&mut self) -> Vec<GeoContainsProperty> {
820		std::mem::take(&mut self.r#geo_contains)
821	}
822	fn get_geo_covered_by(&self) -> &[GeoCoveredByProperty] {
823		self.r#geo_covered_by.as_slice()
824	}
825	fn take_geo_covered_by(&mut self) -> Vec<GeoCoveredByProperty> {
826		std::mem::take(&mut self.r#geo_covered_by)
827	}
828	fn get_geo_covers(&self) -> &[GeoCoversProperty] {
829		self.r#geo_covers.as_slice()
830	}
831	fn take_geo_covers(&mut self) -> Vec<GeoCoversProperty> {
832		std::mem::take(&mut self.r#geo_covers)
833	}
834	fn get_geo_crosses(&self) -> &[GeoCrossesProperty] {
835		self.r#geo_crosses.as_slice()
836	}
837	fn take_geo_crosses(&mut self) -> Vec<GeoCrossesProperty> {
838		std::mem::take(&mut self.r#geo_crosses)
839	}
840	fn get_geo_disjoint(&self) -> &[GeoDisjointProperty] {
841		self.r#geo_disjoint.as_slice()
842	}
843	fn take_geo_disjoint(&mut self) -> Vec<GeoDisjointProperty> {
844		std::mem::take(&mut self.r#geo_disjoint)
845	}
846	fn get_geo_equals(&self) -> &[GeoEqualsProperty] {
847		self.r#geo_equals.as_slice()
848	}
849	fn take_geo_equals(&mut self) -> Vec<GeoEqualsProperty> {
850		std::mem::take(&mut self.r#geo_equals)
851	}
852	fn get_geo_intersects(&self) -> &[GeoIntersectsProperty] {
853		self.r#geo_intersects.as_slice()
854	}
855	fn take_geo_intersects(&mut self) -> Vec<GeoIntersectsProperty> {
856		std::mem::take(&mut self.r#geo_intersects)
857	}
858	fn get_geo_overlaps(&self) -> &[GeoOverlapsProperty] {
859		self.r#geo_overlaps.as_slice()
860	}
861	fn take_geo_overlaps(&mut self) -> Vec<GeoOverlapsProperty> {
862		std::mem::take(&mut self.r#geo_overlaps)
863	}
864	fn get_geo_touches(&self) -> &[GeoTouchesProperty] {
865		self.r#geo_touches.as_slice()
866	}
867	fn take_geo_touches(&mut self) -> Vec<GeoTouchesProperty> {
868		std::mem::take(&mut self.r#geo_touches)
869	}
870	fn get_geo_within(&self) -> &[GeoWithinProperty] {
871		self.r#geo_within.as_slice()
872	}
873	fn take_geo_within(&mut self) -> Vec<GeoWithinProperty> {
874		std::mem::take(&mut self.r#geo_within)
875	}
876	fn get_global_location_number(&self) -> &[GlobalLocationNumberProperty] {
877		self.r#global_location_number.as_slice()
878	}
879	fn take_global_location_number(&mut self) -> Vec<GlobalLocationNumberProperty> {
880		std::mem::take(&mut self.r#global_location_number)
881	}
882	fn get_has_drive_through_service(&self) -> &[HasDriveThroughServiceProperty] {
883		self.r#has_drive_through_service.as_slice()
884	}
885	fn take_has_drive_through_service(&mut self) -> Vec<HasDriveThroughServiceProperty> {
886		std::mem::take(&mut self.r#has_drive_through_service)
887	}
888	fn get_has_map(&self) -> &[HasMapProperty] {
889		self.r#has_map.as_slice()
890	}
891	fn take_has_map(&mut self) -> Vec<HasMapProperty> {
892		std::mem::take(&mut self.r#has_map)
893	}
894	fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
895		self.r#is_accessible_for_free.as_slice()
896	}
897	fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
898		std::mem::take(&mut self.r#is_accessible_for_free)
899	}
900	fn get_isic_v_4(&self) -> &[IsicV4Property] {
901		self.r#isic_v_4.as_slice()
902	}
903	fn take_isic_v_4(&mut self) -> Vec<IsicV4Property> {
904		std::mem::take(&mut self.r#isic_v_4)
905	}
906	fn get_keywords(&self) -> &[KeywordsProperty] {
907		self.r#keywords.as_slice()
908	}
909	fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
910		std::mem::take(&mut self.r#keywords)
911	}
912	fn get_latitude(&self) -> &[LatitudeProperty] {
913		self.r#latitude.as_slice()
914	}
915	fn take_latitude(&mut self) -> Vec<LatitudeProperty> {
916		std::mem::take(&mut self.r#latitude)
917	}
918	fn get_logo(&self) -> &[LogoProperty] {
919		self.r#logo.as_slice()
920	}
921	fn take_logo(&mut self) -> Vec<LogoProperty> {
922		std::mem::take(&mut self.r#logo)
923	}
924	fn get_longitude(&self) -> &[LongitudeProperty] {
925		self.r#longitude.as_slice()
926	}
927	fn take_longitude(&mut self) -> Vec<LongitudeProperty> {
928		std::mem::take(&mut self.r#longitude)
929	}
930	fn get_map(&self) -> &[MapProperty] {
931		self.r#map.as_slice()
932	}
933	fn take_map(&mut self) -> Vec<MapProperty> {
934		std::mem::take(&mut self.r#map)
935	}
936	fn get_maps(&self) -> &[MapsProperty] {
937		self.r#maps.as_slice()
938	}
939	fn take_maps(&mut self) -> Vec<MapsProperty> {
940		std::mem::take(&mut self.r#maps)
941	}
942	fn get_maximum_attendee_capacity(&self) -> &[MaximumAttendeeCapacityProperty] {
943		self.r#maximum_attendee_capacity.as_slice()
944	}
945	fn take_maximum_attendee_capacity(&mut self) -> Vec<MaximumAttendeeCapacityProperty> {
946		std::mem::take(&mut self.r#maximum_attendee_capacity)
947	}
948	fn get_opening_hours_specification(&self) -> &[OpeningHoursSpecificationProperty] {
949		self.r#opening_hours_specification.as_slice()
950	}
951	fn take_opening_hours_specification(&mut self) -> Vec<OpeningHoursSpecificationProperty> {
952		std::mem::take(&mut self.r#opening_hours_specification)
953	}
954	fn get_photo(&self) -> &[PhotoProperty] {
955		self.r#photo.as_slice()
956	}
957	fn take_photo(&mut self) -> Vec<PhotoProperty> {
958		std::mem::take(&mut self.r#photo)
959	}
960	fn get_photos(&self) -> &[PhotosProperty] {
961		self.r#photos.as_slice()
962	}
963	fn take_photos(&mut self) -> Vec<PhotosProperty> {
964		std::mem::take(&mut self.r#photos)
965	}
966	fn get_public_access(&self) -> &[PublicAccessProperty] {
967		self.r#public_access.as_slice()
968	}
969	fn take_public_access(&mut self) -> Vec<PublicAccessProperty> {
970		std::mem::take(&mut self.r#public_access)
971	}
972	fn get_review(&self) -> &[ReviewProperty] {
973		self.r#review.as_slice()
974	}
975	fn take_review(&mut self) -> Vec<ReviewProperty> {
976		std::mem::take(&mut self.r#review)
977	}
978	fn get_reviews(&self) -> &[ReviewsProperty] {
979		self.r#reviews.as_slice()
980	}
981	fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
982		std::mem::take(&mut self.r#reviews)
983	}
984	fn get_slogan(&self) -> &[SloganProperty] {
985		self.r#slogan.as_slice()
986	}
987	fn take_slogan(&mut self) -> Vec<SloganProperty> {
988		std::mem::take(&mut self.r#slogan)
989	}
990	fn get_smoking_allowed(&self) -> &[SmokingAllowedProperty] {
991		self.r#smoking_allowed.as_slice()
992	}
993	fn take_smoking_allowed(&mut self) -> Vec<SmokingAllowedProperty> {
994		std::mem::take(&mut self.r#smoking_allowed)
995	}
996	fn get_special_opening_hours_specification(
997		&self,
998	) -> &[SpecialOpeningHoursSpecificationProperty] {
999		self.r#special_opening_hours_specification.as_slice()
1000	}
1001	fn take_special_opening_hours_specification(
1002		&mut self,
1003	) -> Vec<SpecialOpeningHoursSpecificationProperty> {
1004		std::mem::take(&mut self.r#special_opening_hours_specification)
1005	}
1006	fn get_telephone(&self) -> &[TelephoneProperty] {
1007		self.r#telephone.as_slice()
1008	}
1009	fn take_telephone(&mut self) -> Vec<TelephoneProperty> {
1010		std::mem::take(&mut self.r#telephone)
1011	}
1012	fn get_tour_booking_page(&self) -> &[TourBookingPageProperty] {
1013		self.r#tour_booking_page.as_slice()
1014	}
1015	fn take_tour_booking_page(&mut self) -> Vec<TourBookingPageProperty> {
1016		std::mem::take(&mut self.r#tour_booking_page)
1017	}
1018}
1019impl ThingTrait for IceCreamShop {
1020	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
1021		self.r#additional_type.as_slice()
1022	}
1023	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
1024		std::mem::take(&mut self.r#additional_type)
1025	}
1026	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
1027		self.r#alternate_name.as_slice()
1028	}
1029	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
1030		std::mem::take(&mut self.r#alternate_name)
1031	}
1032	fn get_description(&self) -> &[DescriptionProperty] {
1033		self.r#description.as_slice()
1034	}
1035	fn take_description(&mut self) -> Vec<DescriptionProperty> {
1036		std::mem::take(&mut self.r#description)
1037	}
1038	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
1039		self.r#disambiguating_description.as_slice()
1040	}
1041	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
1042		std::mem::take(&mut self.r#disambiguating_description)
1043	}
1044	fn get_identifier(&self) -> &[IdentifierProperty] {
1045		self.r#identifier.as_slice()
1046	}
1047	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
1048		std::mem::take(&mut self.r#identifier)
1049	}
1050	fn get_image(&self) -> &[ImageProperty] {
1051		self.r#image.as_slice()
1052	}
1053	fn take_image(&mut self) -> Vec<ImageProperty> {
1054		std::mem::take(&mut self.r#image)
1055	}
1056	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
1057		self.r#main_entity_of_page.as_slice()
1058	}
1059	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
1060		std::mem::take(&mut self.r#main_entity_of_page)
1061	}
1062	fn get_name(&self) -> &[NameProperty] {
1063		self.r#name.as_slice()
1064	}
1065	fn take_name(&mut self) -> Vec<NameProperty> {
1066		std::mem::take(&mut self.r#name)
1067	}
1068	fn get_potential_action(&self) -> &[PotentialActionProperty] {
1069		self.r#potential_action.as_slice()
1070	}
1071	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
1072		std::mem::take(&mut self.r#potential_action)
1073	}
1074	fn get_same_as(&self) -> &[SameAsProperty] {
1075		self.r#same_as.as_slice()
1076	}
1077	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
1078		std::mem::take(&mut self.r#same_as)
1079	}
1080	fn get_subject_of(&self) -> &[SubjectOfProperty] {
1081		self.r#subject_of.as_slice()
1082	}
1083	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
1084		std::mem::take(&mut self.r#subject_of)
1085	}
1086	fn get_url(&self) -> &[UrlProperty] {
1087		self.r#url.as_slice()
1088	}
1089	fn take_url(&mut self) -> Vec<UrlProperty> {
1090		std::mem::take(&mut self.r#url)
1091	}
1092}
1093#[cfg(feature = "serde")]
1094mod serde {
1095	use std::{fmt, fmt::Formatter};
1096
1097	use ::serde::{
1098		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
1099	};
1100
1101	use super::*;
1102	impl Serialize for IceCreamShop {
1103		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1104		where
1105			S: Serializer,
1106		{
1107			let len: usize = [
1108				!Vec::is_empty(&self.r#accepts_reservations) as usize,
1109				!Vec::is_empty(&self.r#has_menu) as usize,
1110				!Vec::is_empty(&self.r#menu) as usize,
1111				!Vec::is_empty(&self.r#serves_cuisine) as usize,
1112				!Vec::is_empty(&self.r#star_rating) as usize,
1113				!Vec::is_empty(&self.r#branch_of) as usize,
1114				!Vec::is_empty(&self.r#currencies_accepted) as usize,
1115				!Vec::is_empty(&self.r#opening_hours) as usize,
1116				!Vec::is_empty(&self.r#payment_accepted) as usize,
1117				!Vec::is_empty(&self.r#price_range) as usize,
1118				!Vec::is_empty(&self.r#actionable_feedback_policy) as usize,
1119				!Vec::is_empty(&self.r#address) as usize,
1120				!Vec::is_empty(&self.r#agent_interaction_statistic) as usize,
1121				!Vec::is_empty(&self.r#aggregate_rating) as usize,
1122				!Vec::is_empty(&self.r#alumni) as usize,
1123				!Vec::is_empty(&self.r#area_served) as usize,
1124				!Vec::is_empty(&self.r#award) as usize,
1125				!Vec::is_empty(&self.r#awards) as usize,
1126				!Vec::is_empty(&self.r#brand) as usize,
1127				!Vec::is_empty(&self.r#contact_point) as usize,
1128				!Vec::is_empty(&self.r#contact_points) as usize,
1129				!Vec::is_empty(&self.r#corrections_policy) as usize,
1130				!Vec::is_empty(&self.r#department) as usize,
1131				!Vec::is_empty(&self.r#dissolution_date) as usize,
1132				!Vec::is_empty(&self.r#diversity_policy) as usize,
1133				!Vec::is_empty(&self.r#diversity_staffing_report) as usize,
1134				!Vec::is_empty(&self.r#duns) as usize,
1135				!Vec::is_empty(&self.r#email) as usize,
1136				!Vec::is_empty(&self.r#employee) as usize,
1137				!Vec::is_empty(&self.r#employees) as usize,
1138				!Vec::is_empty(&self.r#ethics_policy) as usize,
1139				!Vec::is_empty(&self.r#event) as usize,
1140				!Vec::is_empty(&self.r#events) as usize,
1141				!Vec::is_empty(&self.r#fax_number) as usize,
1142				!Vec::is_empty(&self.r#founder) as usize,
1143				!Vec::is_empty(&self.r#founders) as usize,
1144				!Vec::is_empty(&self.r#founding_date) as usize,
1145				!Vec::is_empty(&self.r#founding_location) as usize,
1146				!Vec::is_empty(&self.r#funder) as usize,
1147				!Vec::is_empty(&self.r#funding) as usize,
1148				!Vec::is_empty(&self.r#global_location_number) as usize,
1149				!Vec::is_empty(&self.r#has_credential) as usize,
1150				!Vec::is_empty(&self.r#has_merchant_return_policy) as usize,
1151				!Vec::is_empty(&self.r#has_offer_catalog) as usize,
1152				!Vec::is_empty(&self.r#has_pos) as usize,
1153				!Vec::is_empty(&self.r#has_product_return_policy) as usize,
1154				!Vec::is_empty(&self.r#interaction_statistic) as usize,
1155				!Vec::is_empty(&self.r#isic_v_4) as usize,
1156				!Vec::is_empty(&self.r#iso_6523_code) as usize,
1157				!Vec::is_empty(&self.r#keywords) as usize,
1158				!Vec::is_empty(&self.r#knows_about) as usize,
1159				!Vec::is_empty(&self.r#knows_language) as usize,
1160				!Vec::is_empty(&self.r#legal_name) as usize,
1161				!Vec::is_empty(&self.r#lei_code) as usize,
1162				!Vec::is_empty(&self.r#location) as usize,
1163				!Vec::is_empty(&self.r#logo) as usize,
1164				!Vec::is_empty(&self.r#makes_offer) as usize,
1165				!Vec::is_empty(&self.r#member) as usize,
1166				!Vec::is_empty(&self.r#member_of) as usize,
1167				!Vec::is_empty(&self.r#members) as usize,
1168				!Vec::is_empty(&self.r#naics) as usize,
1169				!Vec::is_empty(&self.r#nonprofit_status) as usize,
1170				!Vec::is_empty(&self.r#number_of_employees) as usize,
1171				!Vec::is_empty(&self.r#ownership_funding_info) as usize,
1172				!Vec::is_empty(&self.r#owns) as usize,
1173				!Vec::is_empty(&self.r#parent_organization) as usize,
1174				!Vec::is_empty(&self.r#publishing_principles) as usize,
1175				!Vec::is_empty(&self.r#review) as usize,
1176				!Vec::is_empty(&self.r#reviews) as usize,
1177				!Vec::is_empty(&self.r#seeks) as usize,
1178				!Vec::is_empty(&self.r#service_area) as usize,
1179				!Vec::is_empty(&self.r#slogan) as usize,
1180				!Vec::is_empty(&self.r#sponsor) as usize,
1181				!Vec::is_empty(&self.r#sub_organization) as usize,
1182				!Vec::is_empty(&self.r#tax_id) as usize,
1183				!Vec::is_empty(&self.r#telephone) as usize,
1184				!Vec::is_empty(&self.r#unnamed_sources_policy) as usize,
1185				!Vec::is_empty(&self.r#vat_id) as usize,
1186				!Vec::is_empty(&self.r#additional_property) as usize,
1187				!Vec::is_empty(&self.r#amenity_feature) as usize,
1188				!Vec::is_empty(&self.r#branch_code) as usize,
1189				!Vec::is_empty(&self.r#contained_in) as usize,
1190				!Vec::is_empty(&self.r#contained_in_place) as usize,
1191				!Vec::is_empty(&self.r#contains_place) as usize,
1192				!Vec::is_empty(&self.r#geo) as usize,
1193				!Vec::is_empty(&self.r#geo_contains) as usize,
1194				!Vec::is_empty(&self.r#geo_covered_by) as usize,
1195				!Vec::is_empty(&self.r#geo_covers) as usize,
1196				!Vec::is_empty(&self.r#geo_crosses) as usize,
1197				!Vec::is_empty(&self.r#geo_disjoint) as usize,
1198				!Vec::is_empty(&self.r#geo_equals) as usize,
1199				!Vec::is_empty(&self.r#geo_intersects) as usize,
1200				!Vec::is_empty(&self.r#geo_overlaps) as usize,
1201				!Vec::is_empty(&self.r#geo_touches) as usize,
1202				!Vec::is_empty(&self.r#geo_within) as usize,
1203				!Vec::is_empty(&self.r#has_drive_through_service) as usize,
1204				!Vec::is_empty(&self.r#has_map) as usize,
1205				!Vec::is_empty(&self.r#is_accessible_for_free) as usize,
1206				!Vec::is_empty(&self.r#latitude) as usize,
1207				!Vec::is_empty(&self.r#longitude) as usize,
1208				!Vec::is_empty(&self.r#map) as usize,
1209				!Vec::is_empty(&self.r#maps) as usize,
1210				!Vec::is_empty(&self.r#maximum_attendee_capacity) as usize,
1211				!Vec::is_empty(&self.r#opening_hours_specification) as usize,
1212				!Vec::is_empty(&self.r#photo) as usize,
1213				!Vec::is_empty(&self.r#photos) as usize,
1214				!Vec::is_empty(&self.r#public_access) as usize,
1215				!Vec::is_empty(&self.r#smoking_allowed) as usize,
1216				!Vec::is_empty(&self.r#special_opening_hours_specification) as usize,
1217				!Vec::is_empty(&self.r#tour_booking_page) as usize,
1218				!Vec::is_empty(&self.r#additional_type) as usize,
1219				!Vec::is_empty(&self.r#alternate_name) as usize,
1220				!Vec::is_empty(&self.r#description) as usize,
1221				!Vec::is_empty(&self.r#disambiguating_description) as usize,
1222				!Vec::is_empty(&self.r#identifier) as usize,
1223				!Vec::is_empty(&self.r#image) as usize,
1224				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
1225				!Vec::is_empty(&self.r#name) as usize,
1226				!Vec::is_empty(&self.r#potential_action) as usize,
1227				!Vec::is_empty(&self.r#same_as) as usize,
1228				!Vec::is_empty(&self.r#subject_of) as usize,
1229				!Vec::is_empty(&self.r#url) as usize,
1230			]
1231			.iter()
1232			.sum();
1233			let mut serialize_struct =
1234				Serializer::serialize_struct(serializer, "IceCreamShop", len)?;
1235			if !Vec::is_empty(&self.r#accepts_reservations) {
1236				serialize_struct.serialize_field("acceptsReservations", {
1237					struct SerializeWith<'a>(&'a Vec<AcceptsReservationsProperty>);
1238					impl<'a> Serialize for SerializeWith<'a> {
1239						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1240						where
1241							S: Serializer,
1242						{
1243							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1244								self.0, serializer,
1245							)
1246						}
1247					}
1248					&SerializeWith(&self.r#accepts_reservations)
1249				})?;
1250			} else {
1251				serialize_struct.skip_field("acceptsReservations")?;
1252			}
1253			if !Vec::is_empty(&self.r#has_menu) {
1254				serialize_struct.serialize_field("hasMenu", {
1255					struct SerializeWith<'a>(&'a Vec<HasMenuProperty>);
1256					impl<'a> Serialize for SerializeWith<'a> {
1257						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1258						where
1259							S: Serializer,
1260						{
1261							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1262								self.0, serializer,
1263							)
1264						}
1265					}
1266					&SerializeWith(&self.r#has_menu)
1267				})?;
1268			} else {
1269				serialize_struct.skip_field("hasMenu")?;
1270			}
1271			if !Vec::is_empty(&self.r#menu) {
1272				serialize_struct.serialize_field("menu", {
1273					struct SerializeWith<'a>(&'a Vec<MenuProperty>);
1274					impl<'a> Serialize for SerializeWith<'a> {
1275						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1276						where
1277							S: Serializer,
1278						{
1279							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1280								self.0, serializer,
1281							)
1282						}
1283					}
1284					&SerializeWith(&self.r#menu)
1285				})?;
1286			} else {
1287				serialize_struct.skip_field("menu")?;
1288			}
1289			if !Vec::is_empty(&self.r#serves_cuisine) {
1290				serialize_struct.serialize_field("servesCuisine", {
1291					struct SerializeWith<'a>(&'a Vec<ServesCuisineProperty>);
1292					impl<'a> Serialize for SerializeWith<'a> {
1293						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1294						where
1295							S: Serializer,
1296						{
1297							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1298								self.0, serializer,
1299							)
1300						}
1301					}
1302					&SerializeWith(&self.r#serves_cuisine)
1303				})?;
1304			} else {
1305				serialize_struct.skip_field("servesCuisine")?;
1306			}
1307			if !Vec::is_empty(&self.r#star_rating) {
1308				serialize_struct.serialize_field("starRating", {
1309					struct SerializeWith<'a>(&'a Vec<StarRatingProperty>);
1310					impl<'a> Serialize for SerializeWith<'a> {
1311						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1312						where
1313							S: Serializer,
1314						{
1315							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1316								self.0, serializer,
1317							)
1318						}
1319					}
1320					&SerializeWith(&self.r#star_rating)
1321				})?;
1322			} else {
1323				serialize_struct.skip_field("starRating")?;
1324			}
1325			if !Vec::is_empty(&self.r#branch_of) {
1326				serialize_struct.serialize_field("branchOf", {
1327					struct SerializeWith<'a>(&'a Vec<BranchOfProperty>);
1328					impl<'a> Serialize for SerializeWith<'a> {
1329						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1330						where
1331							S: Serializer,
1332						{
1333							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1334								self.0, serializer,
1335							)
1336						}
1337					}
1338					&SerializeWith(&self.r#branch_of)
1339				})?;
1340			} else {
1341				serialize_struct.skip_field("branchOf")?;
1342			}
1343			if !Vec::is_empty(&self.r#currencies_accepted) {
1344				serialize_struct.serialize_field("currenciesAccepted", {
1345					struct SerializeWith<'a>(&'a Vec<CurrenciesAcceptedProperty>);
1346					impl<'a> Serialize for SerializeWith<'a> {
1347						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1348						where
1349							S: Serializer,
1350						{
1351							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1352								self.0, serializer,
1353							)
1354						}
1355					}
1356					&SerializeWith(&self.r#currencies_accepted)
1357				})?;
1358			} else {
1359				serialize_struct.skip_field("currenciesAccepted")?;
1360			}
1361			if !Vec::is_empty(&self.r#opening_hours) {
1362				serialize_struct.serialize_field("openingHours", {
1363					struct SerializeWith<'a>(&'a Vec<OpeningHoursProperty>);
1364					impl<'a> Serialize for SerializeWith<'a> {
1365						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1366						where
1367							S: Serializer,
1368						{
1369							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1370								self.0, serializer,
1371							)
1372						}
1373					}
1374					&SerializeWith(&self.r#opening_hours)
1375				})?;
1376			} else {
1377				serialize_struct.skip_field("openingHours")?;
1378			}
1379			if !Vec::is_empty(&self.r#payment_accepted) {
1380				serialize_struct.serialize_field("paymentAccepted", {
1381					struct SerializeWith<'a>(&'a Vec<PaymentAcceptedProperty>);
1382					impl<'a> Serialize for SerializeWith<'a> {
1383						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1384						where
1385							S: Serializer,
1386						{
1387							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1388								self.0, serializer,
1389							)
1390						}
1391					}
1392					&SerializeWith(&self.r#payment_accepted)
1393				})?;
1394			} else {
1395				serialize_struct.skip_field("paymentAccepted")?;
1396			}
1397			if !Vec::is_empty(&self.r#price_range) {
1398				serialize_struct.serialize_field("priceRange", {
1399					struct SerializeWith<'a>(&'a Vec<PriceRangeProperty>);
1400					impl<'a> Serialize for SerializeWith<'a> {
1401						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1402						where
1403							S: Serializer,
1404						{
1405							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1406								self.0, serializer,
1407							)
1408						}
1409					}
1410					&SerializeWith(&self.r#price_range)
1411				})?;
1412			} else {
1413				serialize_struct.skip_field("priceRange")?;
1414			}
1415			if !Vec::is_empty(&self.r#actionable_feedback_policy) {
1416				serialize_struct.serialize_field("actionableFeedbackPolicy", {
1417					struct SerializeWith<'a>(&'a Vec<ActionableFeedbackPolicyProperty>);
1418					impl<'a> Serialize for SerializeWith<'a> {
1419						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1420						where
1421							S: Serializer,
1422						{
1423							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1424								self.0, serializer,
1425							)
1426						}
1427					}
1428					&SerializeWith(&self.r#actionable_feedback_policy)
1429				})?;
1430			} else {
1431				serialize_struct.skip_field("actionableFeedbackPolicy")?;
1432			}
1433			if !Vec::is_empty(&self.r#address) {
1434				serialize_struct.serialize_field("address", {
1435					struct SerializeWith<'a>(&'a Vec<AddressProperty>);
1436					impl<'a> Serialize for SerializeWith<'a> {
1437						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1438						where
1439							S: Serializer,
1440						{
1441							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1442								self.0, serializer,
1443							)
1444						}
1445					}
1446					&SerializeWith(&self.r#address)
1447				})?;
1448			} else {
1449				serialize_struct.skip_field("address")?;
1450			}
1451			if !Vec::is_empty(&self.r#agent_interaction_statistic) {
1452				serialize_struct.serialize_field("agentInteractionStatistic", {
1453					struct SerializeWith<'a>(&'a Vec<AgentInteractionStatisticProperty>);
1454					impl<'a> Serialize for SerializeWith<'a> {
1455						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1456						where
1457							S: Serializer,
1458						{
1459							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1460								self.0, serializer,
1461							)
1462						}
1463					}
1464					&SerializeWith(&self.r#agent_interaction_statistic)
1465				})?;
1466			} else {
1467				serialize_struct.skip_field("agentInteractionStatistic")?;
1468			}
1469			if !Vec::is_empty(&self.r#aggregate_rating) {
1470				serialize_struct.serialize_field("aggregateRating", {
1471					struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
1472					impl<'a> Serialize for SerializeWith<'a> {
1473						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1474						where
1475							S: Serializer,
1476						{
1477							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1478								self.0, serializer,
1479							)
1480						}
1481					}
1482					&SerializeWith(&self.r#aggregate_rating)
1483				})?;
1484			} else {
1485				serialize_struct.skip_field("aggregateRating")?;
1486			}
1487			if !Vec::is_empty(&self.r#alumni) {
1488				serialize_struct.serialize_field("alumni", {
1489					struct SerializeWith<'a>(&'a Vec<AlumniProperty>);
1490					impl<'a> Serialize for SerializeWith<'a> {
1491						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1492						where
1493							S: Serializer,
1494						{
1495							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1496								self.0, serializer,
1497							)
1498						}
1499					}
1500					&SerializeWith(&self.r#alumni)
1501				})?;
1502			} else {
1503				serialize_struct.skip_field("alumni")?;
1504			}
1505			if !Vec::is_empty(&self.r#area_served) {
1506				serialize_struct.serialize_field("areaServed", {
1507					struct SerializeWith<'a>(&'a Vec<AreaServedProperty>);
1508					impl<'a> Serialize for SerializeWith<'a> {
1509						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1510						where
1511							S: Serializer,
1512						{
1513							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1514								self.0, serializer,
1515							)
1516						}
1517					}
1518					&SerializeWith(&self.r#area_served)
1519				})?;
1520			} else {
1521				serialize_struct.skip_field("areaServed")?;
1522			}
1523			if !Vec::is_empty(&self.r#award) {
1524				serialize_struct.serialize_field("award", {
1525					struct SerializeWith<'a>(&'a Vec<AwardProperty>);
1526					impl<'a> Serialize for SerializeWith<'a> {
1527						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1528						where
1529							S: Serializer,
1530						{
1531							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1532								self.0, serializer,
1533							)
1534						}
1535					}
1536					&SerializeWith(&self.r#award)
1537				})?;
1538			} else {
1539				serialize_struct.skip_field("award")?;
1540			}
1541			if !Vec::is_empty(&self.r#awards) {
1542				serialize_struct.serialize_field("awards", {
1543					struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
1544					impl<'a> Serialize for SerializeWith<'a> {
1545						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1546						where
1547							S: Serializer,
1548						{
1549							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1550								self.0, serializer,
1551							)
1552						}
1553					}
1554					&SerializeWith(&self.r#awards)
1555				})?;
1556			} else {
1557				serialize_struct.skip_field("awards")?;
1558			}
1559			if !Vec::is_empty(&self.r#brand) {
1560				serialize_struct.serialize_field("brand", {
1561					struct SerializeWith<'a>(&'a Vec<BrandProperty>);
1562					impl<'a> Serialize for SerializeWith<'a> {
1563						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1564						where
1565							S: Serializer,
1566						{
1567							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1568								self.0, serializer,
1569							)
1570						}
1571					}
1572					&SerializeWith(&self.r#brand)
1573				})?;
1574			} else {
1575				serialize_struct.skip_field("brand")?;
1576			}
1577			if !Vec::is_empty(&self.r#contact_point) {
1578				serialize_struct.serialize_field("contactPoint", {
1579					struct SerializeWith<'a>(&'a Vec<ContactPointProperty>);
1580					impl<'a> Serialize for SerializeWith<'a> {
1581						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1582						where
1583							S: Serializer,
1584						{
1585							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1586								self.0, serializer,
1587							)
1588						}
1589					}
1590					&SerializeWith(&self.r#contact_point)
1591				})?;
1592			} else {
1593				serialize_struct.skip_field("contactPoint")?;
1594			}
1595			if !Vec::is_empty(&self.r#contact_points) {
1596				serialize_struct.serialize_field("contactPoints", {
1597					struct SerializeWith<'a>(&'a Vec<ContactPointsProperty>);
1598					impl<'a> Serialize for SerializeWith<'a> {
1599						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1600						where
1601							S: Serializer,
1602						{
1603							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1604								self.0, serializer,
1605							)
1606						}
1607					}
1608					&SerializeWith(&self.r#contact_points)
1609				})?;
1610			} else {
1611				serialize_struct.skip_field("contactPoints")?;
1612			}
1613			if !Vec::is_empty(&self.r#corrections_policy) {
1614				serialize_struct.serialize_field("correctionsPolicy", {
1615					struct SerializeWith<'a>(&'a Vec<CorrectionsPolicyProperty>);
1616					impl<'a> Serialize for SerializeWith<'a> {
1617						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1618						where
1619							S: Serializer,
1620						{
1621							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1622								self.0, serializer,
1623							)
1624						}
1625					}
1626					&SerializeWith(&self.r#corrections_policy)
1627				})?;
1628			} else {
1629				serialize_struct.skip_field("correctionsPolicy")?;
1630			}
1631			if !Vec::is_empty(&self.r#department) {
1632				serialize_struct.serialize_field("department", {
1633					struct SerializeWith<'a>(&'a Vec<DepartmentProperty>);
1634					impl<'a> Serialize for SerializeWith<'a> {
1635						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1636						where
1637							S: Serializer,
1638						{
1639							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1640								self.0, serializer,
1641							)
1642						}
1643					}
1644					&SerializeWith(&self.r#department)
1645				})?;
1646			} else {
1647				serialize_struct.skip_field("department")?;
1648			}
1649			if !Vec::is_empty(&self.r#dissolution_date) {
1650				serialize_struct.serialize_field("dissolutionDate", {
1651					struct SerializeWith<'a>(&'a Vec<DissolutionDateProperty>);
1652					impl<'a> Serialize for SerializeWith<'a> {
1653						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1654						where
1655							S: Serializer,
1656						{
1657							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1658								self.0, serializer,
1659							)
1660						}
1661					}
1662					&SerializeWith(&self.r#dissolution_date)
1663				})?;
1664			} else {
1665				serialize_struct.skip_field("dissolutionDate")?;
1666			}
1667			if !Vec::is_empty(&self.r#diversity_policy) {
1668				serialize_struct.serialize_field("diversityPolicy", {
1669					struct SerializeWith<'a>(&'a Vec<DiversityPolicyProperty>);
1670					impl<'a> Serialize for SerializeWith<'a> {
1671						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1672						where
1673							S: Serializer,
1674						{
1675							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1676								self.0, serializer,
1677							)
1678						}
1679					}
1680					&SerializeWith(&self.r#diversity_policy)
1681				})?;
1682			} else {
1683				serialize_struct.skip_field("diversityPolicy")?;
1684			}
1685			if !Vec::is_empty(&self.r#diversity_staffing_report) {
1686				serialize_struct.serialize_field("diversityStaffingReport", {
1687					struct SerializeWith<'a>(&'a Vec<DiversityStaffingReportProperty>);
1688					impl<'a> Serialize for SerializeWith<'a> {
1689						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1690						where
1691							S: Serializer,
1692						{
1693							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1694								self.0, serializer,
1695							)
1696						}
1697					}
1698					&SerializeWith(&self.r#diversity_staffing_report)
1699				})?;
1700			} else {
1701				serialize_struct.skip_field("diversityStaffingReport")?;
1702			}
1703			if !Vec::is_empty(&self.r#duns) {
1704				serialize_struct.serialize_field("duns", {
1705					struct SerializeWith<'a>(&'a Vec<DunsProperty>);
1706					impl<'a> Serialize for SerializeWith<'a> {
1707						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1708						where
1709							S: Serializer,
1710						{
1711							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1712								self.0, serializer,
1713							)
1714						}
1715					}
1716					&SerializeWith(&self.r#duns)
1717				})?;
1718			} else {
1719				serialize_struct.skip_field("duns")?;
1720			}
1721			if !Vec::is_empty(&self.r#email) {
1722				serialize_struct.serialize_field("email", {
1723					struct SerializeWith<'a>(&'a Vec<EmailProperty>);
1724					impl<'a> Serialize for SerializeWith<'a> {
1725						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1726						where
1727							S: Serializer,
1728						{
1729							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1730								self.0, serializer,
1731							)
1732						}
1733					}
1734					&SerializeWith(&self.r#email)
1735				})?;
1736			} else {
1737				serialize_struct.skip_field("email")?;
1738			}
1739			if !Vec::is_empty(&self.r#employee) {
1740				serialize_struct.serialize_field("employee", {
1741					struct SerializeWith<'a>(&'a Vec<EmployeeProperty>);
1742					impl<'a> Serialize for SerializeWith<'a> {
1743						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1744						where
1745							S: Serializer,
1746						{
1747							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1748								self.0, serializer,
1749							)
1750						}
1751					}
1752					&SerializeWith(&self.r#employee)
1753				})?;
1754			} else {
1755				serialize_struct.skip_field("employee")?;
1756			}
1757			if !Vec::is_empty(&self.r#employees) {
1758				serialize_struct.serialize_field("employees", {
1759					struct SerializeWith<'a>(&'a Vec<EmployeesProperty>);
1760					impl<'a> Serialize for SerializeWith<'a> {
1761						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1762						where
1763							S: Serializer,
1764						{
1765							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1766								self.0, serializer,
1767							)
1768						}
1769					}
1770					&SerializeWith(&self.r#employees)
1771				})?;
1772			} else {
1773				serialize_struct.skip_field("employees")?;
1774			}
1775			if !Vec::is_empty(&self.r#ethics_policy) {
1776				serialize_struct.serialize_field("ethicsPolicy", {
1777					struct SerializeWith<'a>(&'a Vec<EthicsPolicyProperty>);
1778					impl<'a> Serialize for SerializeWith<'a> {
1779						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1780						where
1781							S: Serializer,
1782						{
1783							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1784								self.0, serializer,
1785							)
1786						}
1787					}
1788					&SerializeWith(&self.r#ethics_policy)
1789				})?;
1790			} else {
1791				serialize_struct.skip_field("ethicsPolicy")?;
1792			}
1793			if !Vec::is_empty(&self.r#event) {
1794				serialize_struct.serialize_field("event", {
1795					struct SerializeWith<'a>(&'a Vec<EventProperty>);
1796					impl<'a> Serialize for SerializeWith<'a> {
1797						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1798						where
1799							S: Serializer,
1800						{
1801							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1802								self.0, serializer,
1803							)
1804						}
1805					}
1806					&SerializeWith(&self.r#event)
1807				})?;
1808			} else {
1809				serialize_struct.skip_field("event")?;
1810			}
1811			if !Vec::is_empty(&self.r#events) {
1812				serialize_struct.serialize_field("events", {
1813					struct SerializeWith<'a>(&'a Vec<EventsProperty>);
1814					impl<'a> Serialize for SerializeWith<'a> {
1815						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1816						where
1817							S: Serializer,
1818						{
1819							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1820								self.0, serializer,
1821							)
1822						}
1823					}
1824					&SerializeWith(&self.r#events)
1825				})?;
1826			} else {
1827				serialize_struct.skip_field("events")?;
1828			}
1829			if !Vec::is_empty(&self.r#fax_number) {
1830				serialize_struct.serialize_field("faxNumber", {
1831					struct SerializeWith<'a>(&'a Vec<FaxNumberProperty>);
1832					impl<'a> Serialize for SerializeWith<'a> {
1833						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1834						where
1835							S: Serializer,
1836						{
1837							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1838								self.0, serializer,
1839							)
1840						}
1841					}
1842					&SerializeWith(&self.r#fax_number)
1843				})?;
1844			} else {
1845				serialize_struct.skip_field("faxNumber")?;
1846			}
1847			if !Vec::is_empty(&self.r#founder) {
1848				serialize_struct.serialize_field("founder", {
1849					struct SerializeWith<'a>(&'a Vec<FounderProperty>);
1850					impl<'a> Serialize for SerializeWith<'a> {
1851						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1852						where
1853							S: Serializer,
1854						{
1855							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1856								self.0, serializer,
1857							)
1858						}
1859					}
1860					&SerializeWith(&self.r#founder)
1861				})?;
1862			} else {
1863				serialize_struct.skip_field("founder")?;
1864			}
1865			if !Vec::is_empty(&self.r#founders) {
1866				serialize_struct.serialize_field("founders", {
1867					struct SerializeWith<'a>(&'a Vec<FoundersProperty>);
1868					impl<'a> Serialize for SerializeWith<'a> {
1869						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1870						where
1871							S: Serializer,
1872						{
1873							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1874								self.0, serializer,
1875							)
1876						}
1877					}
1878					&SerializeWith(&self.r#founders)
1879				})?;
1880			} else {
1881				serialize_struct.skip_field("founders")?;
1882			}
1883			if !Vec::is_empty(&self.r#founding_date) {
1884				serialize_struct.serialize_field("foundingDate", {
1885					struct SerializeWith<'a>(&'a Vec<FoundingDateProperty>);
1886					impl<'a> Serialize for SerializeWith<'a> {
1887						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1888						where
1889							S: Serializer,
1890						{
1891							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1892								self.0, serializer,
1893							)
1894						}
1895					}
1896					&SerializeWith(&self.r#founding_date)
1897				})?;
1898			} else {
1899				serialize_struct.skip_field("foundingDate")?;
1900			}
1901			if !Vec::is_empty(&self.r#founding_location) {
1902				serialize_struct.serialize_field("foundingLocation", {
1903					struct SerializeWith<'a>(&'a Vec<FoundingLocationProperty>);
1904					impl<'a> Serialize for SerializeWith<'a> {
1905						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1906						where
1907							S: Serializer,
1908						{
1909							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1910								self.0, serializer,
1911							)
1912						}
1913					}
1914					&SerializeWith(&self.r#founding_location)
1915				})?;
1916			} else {
1917				serialize_struct.skip_field("foundingLocation")?;
1918			}
1919			if !Vec::is_empty(&self.r#funder) {
1920				serialize_struct.serialize_field("funder", {
1921					struct SerializeWith<'a>(&'a Vec<FunderProperty>);
1922					impl<'a> Serialize for SerializeWith<'a> {
1923						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1924						where
1925							S: Serializer,
1926						{
1927							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1928								self.0, serializer,
1929							)
1930						}
1931					}
1932					&SerializeWith(&self.r#funder)
1933				})?;
1934			} else {
1935				serialize_struct.skip_field("funder")?;
1936			}
1937			if !Vec::is_empty(&self.r#funding) {
1938				serialize_struct.serialize_field("funding", {
1939					struct SerializeWith<'a>(&'a Vec<FundingProperty>);
1940					impl<'a> Serialize for SerializeWith<'a> {
1941						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1942						where
1943							S: Serializer,
1944						{
1945							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1946								self.0, serializer,
1947							)
1948						}
1949					}
1950					&SerializeWith(&self.r#funding)
1951				})?;
1952			} else {
1953				serialize_struct.skip_field("funding")?;
1954			}
1955			if !Vec::is_empty(&self.r#global_location_number) {
1956				serialize_struct.serialize_field("globalLocationNumber", {
1957					struct SerializeWith<'a>(&'a Vec<GlobalLocationNumberProperty>);
1958					impl<'a> Serialize for SerializeWith<'a> {
1959						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1960						where
1961							S: Serializer,
1962						{
1963							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1964								self.0, serializer,
1965							)
1966						}
1967					}
1968					&SerializeWith(&self.r#global_location_number)
1969				})?;
1970			} else {
1971				serialize_struct.skip_field("globalLocationNumber")?;
1972			}
1973			if !Vec::is_empty(&self.r#has_credential) {
1974				serialize_struct.serialize_field("hasCredential", {
1975					struct SerializeWith<'a>(&'a Vec<HasCredentialProperty>);
1976					impl<'a> Serialize for SerializeWith<'a> {
1977						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1978						where
1979							S: Serializer,
1980						{
1981							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1982								self.0, serializer,
1983							)
1984						}
1985					}
1986					&SerializeWith(&self.r#has_credential)
1987				})?;
1988			} else {
1989				serialize_struct.skip_field("hasCredential")?;
1990			}
1991			if !Vec::is_empty(&self.r#has_merchant_return_policy) {
1992				serialize_struct.serialize_field("hasMerchantReturnPolicy", {
1993					struct SerializeWith<'a>(&'a Vec<HasMerchantReturnPolicyProperty>);
1994					impl<'a> Serialize for SerializeWith<'a> {
1995						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1996						where
1997							S: Serializer,
1998						{
1999							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2000								self.0, serializer,
2001							)
2002						}
2003					}
2004					&SerializeWith(&self.r#has_merchant_return_policy)
2005				})?;
2006			} else {
2007				serialize_struct.skip_field("hasMerchantReturnPolicy")?;
2008			}
2009			if !Vec::is_empty(&self.r#has_offer_catalog) {
2010				serialize_struct.serialize_field("hasOfferCatalog", {
2011					struct SerializeWith<'a>(&'a Vec<HasOfferCatalogProperty>);
2012					impl<'a> Serialize for SerializeWith<'a> {
2013						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2014						where
2015							S: Serializer,
2016						{
2017							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2018								self.0, serializer,
2019							)
2020						}
2021					}
2022					&SerializeWith(&self.r#has_offer_catalog)
2023				})?;
2024			} else {
2025				serialize_struct.skip_field("hasOfferCatalog")?;
2026			}
2027			if !Vec::is_empty(&self.r#has_pos) {
2028				serialize_struct.serialize_field("hasPOS", {
2029					struct SerializeWith<'a>(&'a Vec<HasPosProperty>);
2030					impl<'a> Serialize for SerializeWith<'a> {
2031						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2032						where
2033							S: Serializer,
2034						{
2035							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2036								self.0, serializer,
2037							)
2038						}
2039					}
2040					&SerializeWith(&self.r#has_pos)
2041				})?;
2042			} else {
2043				serialize_struct.skip_field("hasPOS")?;
2044			}
2045			if !Vec::is_empty(&self.r#has_product_return_policy) {
2046				serialize_struct.serialize_field("hasProductReturnPolicy", {
2047					struct SerializeWith<'a>(&'a Vec<HasProductReturnPolicyProperty>);
2048					impl<'a> Serialize for SerializeWith<'a> {
2049						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2050						where
2051							S: Serializer,
2052						{
2053							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2054								self.0, serializer,
2055							)
2056						}
2057					}
2058					&SerializeWith(&self.r#has_product_return_policy)
2059				})?;
2060			} else {
2061				serialize_struct.skip_field("hasProductReturnPolicy")?;
2062			}
2063			if !Vec::is_empty(&self.r#interaction_statistic) {
2064				serialize_struct.serialize_field("interactionStatistic", {
2065					struct SerializeWith<'a>(&'a Vec<InteractionStatisticProperty>);
2066					impl<'a> Serialize for SerializeWith<'a> {
2067						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2068						where
2069							S: Serializer,
2070						{
2071							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2072								self.0, serializer,
2073							)
2074						}
2075					}
2076					&SerializeWith(&self.r#interaction_statistic)
2077				})?;
2078			} else {
2079				serialize_struct.skip_field("interactionStatistic")?;
2080			}
2081			if !Vec::is_empty(&self.r#isic_v_4) {
2082				serialize_struct.serialize_field("isicV4", {
2083					struct SerializeWith<'a>(&'a Vec<IsicV4Property>);
2084					impl<'a> Serialize for SerializeWith<'a> {
2085						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2086						where
2087							S: Serializer,
2088						{
2089							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2090								self.0, serializer,
2091							)
2092						}
2093					}
2094					&SerializeWith(&self.r#isic_v_4)
2095				})?;
2096			} else {
2097				serialize_struct.skip_field("isicV4")?;
2098			}
2099			if !Vec::is_empty(&self.r#iso_6523_code) {
2100				serialize_struct.serialize_field("iso6523Code", {
2101					struct SerializeWith<'a>(&'a Vec<Iso6523CodeProperty>);
2102					impl<'a> Serialize for SerializeWith<'a> {
2103						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2104						where
2105							S: Serializer,
2106						{
2107							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2108								self.0, serializer,
2109							)
2110						}
2111					}
2112					&SerializeWith(&self.r#iso_6523_code)
2113				})?;
2114			} else {
2115				serialize_struct.skip_field("iso6523Code")?;
2116			}
2117			if !Vec::is_empty(&self.r#keywords) {
2118				serialize_struct.serialize_field("keywords", {
2119					struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
2120					impl<'a> Serialize for SerializeWith<'a> {
2121						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2122						where
2123							S: Serializer,
2124						{
2125							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2126								self.0, serializer,
2127							)
2128						}
2129					}
2130					&SerializeWith(&self.r#keywords)
2131				})?;
2132			} else {
2133				serialize_struct.skip_field("keywords")?;
2134			}
2135			if !Vec::is_empty(&self.r#knows_about) {
2136				serialize_struct.serialize_field("knowsAbout", {
2137					struct SerializeWith<'a>(&'a Vec<KnowsAboutProperty>);
2138					impl<'a> Serialize for SerializeWith<'a> {
2139						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2140						where
2141							S: Serializer,
2142						{
2143							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2144								self.0, serializer,
2145							)
2146						}
2147					}
2148					&SerializeWith(&self.r#knows_about)
2149				})?;
2150			} else {
2151				serialize_struct.skip_field("knowsAbout")?;
2152			}
2153			if !Vec::is_empty(&self.r#knows_language) {
2154				serialize_struct.serialize_field("knowsLanguage", {
2155					struct SerializeWith<'a>(&'a Vec<KnowsLanguageProperty>);
2156					impl<'a> Serialize for SerializeWith<'a> {
2157						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2158						where
2159							S: Serializer,
2160						{
2161							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2162								self.0, serializer,
2163							)
2164						}
2165					}
2166					&SerializeWith(&self.r#knows_language)
2167				})?;
2168			} else {
2169				serialize_struct.skip_field("knowsLanguage")?;
2170			}
2171			if !Vec::is_empty(&self.r#legal_name) {
2172				serialize_struct.serialize_field("legalName", {
2173					struct SerializeWith<'a>(&'a Vec<LegalNameProperty>);
2174					impl<'a> Serialize for SerializeWith<'a> {
2175						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2176						where
2177							S: Serializer,
2178						{
2179							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2180								self.0, serializer,
2181							)
2182						}
2183					}
2184					&SerializeWith(&self.r#legal_name)
2185				})?;
2186			} else {
2187				serialize_struct.skip_field("legalName")?;
2188			}
2189			if !Vec::is_empty(&self.r#lei_code) {
2190				serialize_struct.serialize_field("leiCode", {
2191					struct SerializeWith<'a>(&'a Vec<LeiCodeProperty>);
2192					impl<'a> Serialize for SerializeWith<'a> {
2193						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2194						where
2195							S: Serializer,
2196						{
2197							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2198								self.0, serializer,
2199							)
2200						}
2201					}
2202					&SerializeWith(&self.r#lei_code)
2203				})?;
2204			} else {
2205				serialize_struct.skip_field("leiCode")?;
2206			}
2207			if !Vec::is_empty(&self.r#location) {
2208				serialize_struct.serialize_field("location", {
2209					struct SerializeWith<'a>(&'a Vec<LocationProperty>);
2210					impl<'a> Serialize for SerializeWith<'a> {
2211						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2212						where
2213							S: Serializer,
2214						{
2215							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2216								self.0, serializer,
2217							)
2218						}
2219					}
2220					&SerializeWith(&self.r#location)
2221				})?;
2222			} else {
2223				serialize_struct.skip_field("location")?;
2224			}
2225			if !Vec::is_empty(&self.r#logo) {
2226				serialize_struct.serialize_field("logo", {
2227					struct SerializeWith<'a>(&'a Vec<LogoProperty>);
2228					impl<'a> Serialize for SerializeWith<'a> {
2229						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2230						where
2231							S: Serializer,
2232						{
2233							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2234								self.0, serializer,
2235							)
2236						}
2237					}
2238					&SerializeWith(&self.r#logo)
2239				})?;
2240			} else {
2241				serialize_struct.skip_field("logo")?;
2242			}
2243			if !Vec::is_empty(&self.r#makes_offer) {
2244				serialize_struct.serialize_field("makesOffer", {
2245					struct SerializeWith<'a>(&'a Vec<MakesOfferProperty>);
2246					impl<'a> Serialize for SerializeWith<'a> {
2247						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2248						where
2249							S: Serializer,
2250						{
2251							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2252								self.0, serializer,
2253							)
2254						}
2255					}
2256					&SerializeWith(&self.r#makes_offer)
2257				})?;
2258			} else {
2259				serialize_struct.skip_field("makesOffer")?;
2260			}
2261			if !Vec::is_empty(&self.r#member) {
2262				serialize_struct.serialize_field("member", {
2263					struct SerializeWith<'a>(&'a Vec<MemberProperty>);
2264					impl<'a> Serialize for SerializeWith<'a> {
2265						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2266						where
2267							S: Serializer,
2268						{
2269							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2270								self.0, serializer,
2271							)
2272						}
2273					}
2274					&SerializeWith(&self.r#member)
2275				})?;
2276			} else {
2277				serialize_struct.skip_field("member")?;
2278			}
2279			if !Vec::is_empty(&self.r#member_of) {
2280				serialize_struct.serialize_field("memberOf", {
2281					struct SerializeWith<'a>(&'a Vec<MemberOfProperty>);
2282					impl<'a> Serialize for SerializeWith<'a> {
2283						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2284						where
2285							S: Serializer,
2286						{
2287							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2288								self.0, serializer,
2289							)
2290						}
2291					}
2292					&SerializeWith(&self.r#member_of)
2293				})?;
2294			} else {
2295				serialize_struct.skip_field("memberOf")?;
2296			}
2297			if !Vec::is_empty(&self.r#members) {
2298				serialize_struct.serialize_field("members", {
2299					struct SerializeWith<'a>(&'a Vec<MembersProperty>);
2300					impl<'a> Serialize for SerializeWith<'a> {
2301						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2302						where
2303							S: Serializer,
2304						{
2305							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2306								self.0, serializer,
2307							)
2308						}
2309					}
2310					&SerializeWith(&self.r#members)
2311				})?;
2312			} else {
2313				serialize_struct.skip_field("members")?;
2314			}
2315			if !Vec::is_empty(&self.r#naics) {
2316				serialize_struct.serialize_field("naics", {
2317					struct SerializeWith<'a>(&'a Vec<NaicsProperty>);
2318					impl<'a> Serialize for SerializeWith<'a> {
2319						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2320						where
2321							S: Serializer,
2322						{
2323							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2324								self.0, serializer,
2325							)
2326						}
2327					}
2328					&SerializeWith(&self.r#naics)
2329				})?;
2330			} else {
2331				serialize_struct.skip_field("naics")?;
2332			}
2333			if !Vec::is_empty(&self.r#nonprofit_status) {
2334				serialize_struct.serialize_field("nonprofitStatus", {
2335					struct SerializeWith<'a>(&'a Vec<NonprofitStatusProperty>);
2336					impl<'a> Serialize for SerializeWith<'a> {
2337						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2338						where
2339							S: Serializer,
2340						{
2341							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2342								self.0, serializer,
2343							)
2344						}
2345					}
2346					&SerializeWith(&self.r#nonprofit_status)
2347				})?;
2348			} else {
2349				serialize_struct.skip_field("nonprofitStatus")?;
2350			}
2351			if !Vec::is_empty(&self.r#number_of_employees) {
2352				serialize_struct.serialize_field("numberOfEmployees", {
2353					struct SerializeWith<'a>(&'a Vec<NumberOfEmployeesProperty>);
2354					impl<'a> Serialize for SerializeWith<'a> {
2355						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2356						where
2357							S: Serializer,
2358						{
2359							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2360								self.0, serializer,
2361							)
2362						}
2363					}
2364					&SerializeWith(&self.r#number_of_employees)
2365				})?;
2366			} else {
2367				serialize_struct.skip_field("numberOfEmployees")?;
2368			}
2369			if !Vec::is_empty(&self.r#ownership_funding_info) {
2370				serialize_struct.serialize_field("ownershipFundingInfo", {
2371					struct SerializeWith<'a>(&'a Vec<OwnershipFundingInfoProperty>);
2372					impl<'a> Serialize for SerializeWith<'a> {
2373						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2374						where
2375							S: Serializer,
2376						{
2377							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2378								self.0, serializer,
2379							)
2380						}
2381					}
2382					&SerializeWith(&self.r#ownership_funding_info)
2383				})?;
2384			} else {
2385				serialize_struct.skip_field("ownershipFundingInfo")?;
2386			}
2387			if !Vec::is_empty(&self.r#owns) {
2388				serialize_struct.serialize_field("owns", {
2389					struct SerializeWith<'a>(&'a Vec<OwnsProperty>);
2390					impl<'a> Serialize for SerializeWith<'a> {
2391						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2392						where
2393							S: Serializer,
2394						{
2395							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2396								self.0, serializer,
2397							)
2398						}
2399					}
2400					&SerializeWith(&self.r#owns)
2401				})?;
2402			} else {
2403				serialize_struct.skip_field("owns")?;
2404			}
2405			if !Vec::is_empty(&self.r#parent_organization) {
2406				serialize_struct.serialize_field("parentOrganization", {
2407					struct SerializeWith<'a>(&'a Vec<ParentOrganizationProperty>);
2408					impl<'a> Serialize for SerializeWith<'a> {
2409						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2410						where
2411							S: Serializer,
2412						{
2413							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2414								self.0, serializer,
2415							)
2416						}
2417					}
2418					&SerializeWith(&self.r#parent_organization)
2419				})?;
2420			} else {
2421				serialize_struct.skip_field("parentOrganization")?;
2422			}
2423			if !Vec::is_empty(&self.r#publishing_principles) {
2424				serialize_struct.serialize_field("publishingPrinciples", {
2425					struct SerializeWith<'a>(&'a Vec<PublishingPrinciplesProperty>);
2426					impl<'a> Serialize for SerializeWith<'a> {
2427						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2428						where
2429							S: Serializer,
2430						{
2431							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2432								self.0, serializer,
2433							)
2434						}
2435					}
2436					&SerializeWith(&self.r#publishing_principles)
2437				})?;
2438			} else {
2439				serialize_struct.skip_field("publishingPrinciples")?;
2440			}
2441			if !Vec::is_empty(&self.r#review) {
2442				serialize_struct.serialize_field("review", {
2443					struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
2444					impl<'a> Serialize for SerializeWith<'a> {
2445						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2446						where
2447							S: Serializer,
2448						{
2449							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2450								self.0, serializer,
2451							)
2452						}
2453					}
2454					&SerializeWith(&self.r#review)
2455				})?;
2456			} else {
2457				serialize_struct.skip_field("review")?;
2458			}
2459			if !Vec::is_empty(&self.r#reviews) {
2460				serialize_struct.serialize_field("reviews", {
2461					struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
2462					impl<'a> Serialize for SerializeWith<'a> {
2463						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2464						where
2465							S: Serializer,
2466						{
2467							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2468								self.0, serializer,
2469							)
2470						}
2471					}
2472					&SerializeWith(&self.r#reviews)
2473				})?;
2474			} else {
2475				serialize_struct.skip_field("reviews")?;
2476			}
2477			if !Vec::is_empty(&self.r#seeks) {
2478				serialize_struct.serialize_field("seeks", {
2479					struct SerializeWith<'a>(&'a Vec<SeeksProperty>);
2480					impl<'a> Serialize for SerializeWith<'a> {
2481						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2482						where
2483							S: Serializer,
2484						{
2485							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2486								self.0, serializer,
2487							)
2488						}
2489					}
2490					&SerializeWith(&self.r#seeks)
2491				})?;
2492			} else {
2493				serialize_struct.skip_field("seeks")?;
2494			}
2495			if !Vec::is_empty(&self.r#service_area) {
2496				serialize_struct.serialize_field("serviceArea", {
2497					struct SerializeWith<'a>(&'a Vec<ServiceAreaProperty>);
2498					impl<'a> Serialize for SerializeWith<'a> {
2499						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2500						where
2501							S: Serializer,
2502						{
2503							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2504								self.0, serializer,
2505							)
2506						}
2507					}
2508					&SerializeWith(&self.r#service_area)
2509				})?;
2510			} else {
2511				serialize_struct.skip_field("serviceArea")?;
2512			}
2513			if !Vec::is_empty(&self.r#slogan) {
2514				serialize_struct.serialize_field("slogan", {
2515					struct SerializeWith<'a>(&'a Vec<SloganProperty>);
2516					impl<'a> Serialize for SerializeWith<'a> {
2517						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2518						where
2519							S: Serializer,
2520						{
2521							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2522								self.0, serializer,
2523							)
2524						}
2525					}
2526					&SerializeWith(&self.r#slogan)
2527				})?;
2528			} else {
2529				serialize_struct.skip_field("slogan")?;
2530			}
2531			if !Vec::is_empty(&self.r#sponsor) {
2532				serialize_struct.serialize_field("sponsor", {
2533					struct SerializeWith<'a>(&'a Vec<SponsorProperty>);
2534					impl<'a> Serialize for SerializeWith<'a> {
2535						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2536						where
2537							S: Serializer,
2538						{
2539							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2540								self.0, serializer,
2541							)
2542						}
2543					}
2544					&SerializeWith(&self.r#sponsor)
2545				})?;
2546			} else {
2547				serialize_struct.skip_field("sponsor")?;
2548			}
2549			if !Vec::is_empty(&self.r#sub_organization) {
2550				serialize_struct.serialize_field("subOrganization", {
2551					struct SerializeWith<'a>(&'a Vec<SubOrganizationProperty>);
2552					impl<'a> Serialize for SerializeWith<'a> {
2553						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2554						where
2555							S: Serializer,
2556						{
2557							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2558								self.0, serializer,
2559							)
2560						}
2561					}
2562					&SerializeWith(&self.r#sub_organization)
2563				})?;
2564			} else {
2565				serialize_struct.skip_field("subOrganization")?;
2566			}
2567			if !Vec::is_empty(&self.r#tax_id) {
2568				serialize_struct.serialize_field("taxID", {
2569					struct SerializeWith<'a>(&'a Vec<TaxIdProperty>);
2570					impl<'a> Serialize for SerializeWith<'a> {
2571						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2572						where
2573							S: Serializer,
2574						{
2575							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2576								self.0, serializer,
2577							)
2578						}
2579					}
2580					&SerializeWith(&self.r#tax_id)
2581				})?;
2582			} else {
2583				serialize_struct.skip_field("taxID")?;
2584			}
2585			if !Vec::is_empty(&self.r#telephone) {
2586				serialize_struct.serialize_field("telephone", {
2587					struct SerializeWith<'a>(&'a Vec<TelephoneProperty>);
2588					impl<'a> Serialize for SerializeWith<'a> {
2589						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2590						where
2591							S: Serializer,
2592						{
2593							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2594								self.0, serializer,
2595							)
2596						}
2597					}
2598					&SerializeWith(&self.r#telephone)
2599				})?;
2600			} else {
2601				serialize_struct.skip_field("telephone")?;
2602			}
2603			if !Vec::is_empty(&self.r#unnamed_sources_policy) {
2604				serialize_struct.serialize_field("unnamedSourcesPolicy", {
2605					struct SerializeWith<'a>(&'a Vec<UnnamedSourcesPolicyProperty>);
2606					impl<'a> Serialize for SerializeWith<'a> {
2607						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2608						where
2609							S: Serializer,
2610						{
2611							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2612								self.0, serializer,
2613							)
2614						}
2615					}
2616					&SerializeWith(&self.r#unnamed_sources_policy)
2617				})?;
2618			} else {
2619				serialize_struct.skip_field("unnamedSourcesPolicy")?;
2620			}
2621			if !Vec::is_empty(&self.r#vat_id) {
2622				serialize_struct.serialize_field("vatID", {
2623					struct SerializeWith<'a>(&'a Vec<VatIdProperty>);
2624					impl<'a> Serialize for SerializeWith<'a> {
2625						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2626						where
2627							S: Serializer,
2628						{
2629							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2630								self.0, serializer,
2631							)
2632						}
2633					}
2634					&SerializeWith(&self.r#vat_id)
2635				})?;
2636			} else {
2637				serialize_struct.skip_field("vatID")?;
2638			}
2639			if !Vec::is_empty(&self.r#additional_property) {
2640				serialize_struct.serialize_field("additionalProperty", {
2641					struct SerializeWith<'a>(&'a Vec<AdditionalPropertyProperty>);
2642					impl<'a> Serialize for SerializeWith<'a> {
2643						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2644						where
2645							S: Serializer,
2646						{
2647							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2648								self.0, serializer,
2649							)
2650						}
2651					}
2652					&SerializeWith(&self.r#additional_property)
2653				})?;
2654			} else {
2655				serialize_struct.skip_field("additionalProperty")?;
2656			}
2657			if !Vec::is_empty(&self.r#amenity_feature) {
2658				serialize_struct.serialize_field("amenityFeature", {
2659					struct SerializeWith<'a>(&'a Vec<AmenityFeatureProperty>);
2660					impl<'a> Serialize for SerializeWith<'a> {
2661						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2662						where
2663							S: Serializer,
2664						{
2665							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2666								self.0, serializer,
2667							)
2668						}
2669					}
2670					&SerializeWith(&self.r#amenity_feature)
2671				})?;
2672			} else {
2673				serialize_struct.skip_field("amenityFeature")?;
2674			}
2675			if !Vec::is_empty(&self.r#branch_code) {
2676				serialize_struct.serialize_field("branchCode", {
2677					struct SerializeWith<'a>(&'a Vec<BranchCodeProperty>);
2678					impl<'a> Serialize for SerializeWith<'a> {
2679						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2680						where
2681							S: Serializer,
2682						{
2683							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2684								self.0, serializer,
2685							)
2686						}
2687					}
2688					&SerializeWith(&self.r#branch_code)
2689				})?;
2690			} else {
2691				serialize_struct.skip_field("branchCode")?;
2692			}
2693			if !Vec::is_empty(&self.r#contained_in) {
2694				serialize_struct.serialize_field("containedIn", {
2695					struct SerializeWith<'a>(&'a Vec<ContainedInProperty>);
2696					impl<'a> Serialize for SerializeWith<'a> {
2697						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2698						where
2699							S: Serializer,
2700						{
2701							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2702								self.0, serializer,
2703							)
2704						}
2705					}
2706					&SerializeWith(&self.r#contained_in)
2707				})?;
2708			} else {
2709				serialize_struct.skip_field("containedIn")?;
2710			}
2711			if !Vec::is_empty(&self.r#contained_in_place) {
2712				serialize_struct.serialize_field("containedInPlace", {
2713					struct SerializeWith<'a>(&'a Vec<ContainedInPlaceProperty>);
2714					impl<'a> Serialize for SerializeWith<'a> {
2715						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2716						where
2717							S: Serializer,
2718						{
2719							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2720								self.0, serializer,
2721							)
2722						}
2723					}
2724					&SerializeWith(&self.r#contained_in_place)
2725				})?;
2726			} else {
2727				serialize_struct.skip_field("containedInPlace")?;
2728			}
2729			if !Vec::is_empty(&self.r#contains_place) {
2730				serialize_struct.serialize_field("containsPlace", {
2731					struct SerializeWith<'a>(&'a Vec<ContainsPlaceProperty>);
2732					impl<'a> Serialize for SerializeWith<'a> {
2733						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2734						where
2735							S: Serializer,
2736						{
2737							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2738								self.0, serializer,
2739							)
2740						}
2741					}
2742					&SerializeWith(&self.r#contains_place)
2743				})?;
2744			} else {
2745				serialize_struct.skip_field("containsPlace")?;
2746			}
2747			if !Vec::is_empty(&self.r#geo) {
2748				serialize_struct.serialize_field("geo", {
2749					struct SerializeWith<'a>(&'a Vec<GeoProperty>);
2750					impl<'a> Serialize for SerializeWith<'a> {
2751						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2752						where
2753							S: Serializer,
2754						{
2755							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2756								self.0, serializer,
2757							)
2758						}
2759					}
2760					&SerializeWith(&self.r#geo)
2761				})?;
2762			} else {
2763				serialize_struct.skip_field("geo")?;
2764			}
2765			if !Vec::is_empty(&self.r#geo_contains) {
2766				serialize_struct.serialize_field("geoContains", {
2767					struct SerializeWith<'a>(&'a Vec<GeoContainsProperty>);
2768					impl<'a> Serialize for SerializeWith<'a> {
2769						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2770						where
2771							S: Serializer,
2772						{
2773							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2774								self.0, serializer,
2775							)
2776						}
2777					}
2778					&SerializeWith(&self.r#geo_contains)
2779				})?;
2780			} else {
2781				serialize_struct.skip_field("geoContains")?;
2782			}
2783			if !Vec::is_empty(&self.r#geo_covered_by) {
2784				serialize_struct.serialize_field("geoCoveredBy", {
2785					struct SerializeWith<'a>(&'a Vec<GeoCoveredByProperty>);
2786					impl<'a> Serialize for SerializeWith<'a> {
2787						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2788						where
2789							S: Serializer,
2790						{
2791							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2792								self.0, serializer,
2793							)
2794						}
2795					}
2796					&SerializeWith(&self.r#geo_covered_by)
2797				})?;
2798			} else {
2799				serialize_struct.skip_field("geoCoveredBy")?;
2800			}
2801			if !Vec::is_empty(&self.r#geo_covers) {
2802				serialize_struct.serialize_field("geoCovers", {
2803					struct SerializeWith<'a>(&'a Vec<GeoCoversProperty>);
2804					impl<'a> Serialize for SerializeWith<'a> {
2805						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2806						where
2807							S: Serializer,
2808						{
2809							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2810								self.0, serializer,
2811							)
2812						}
2813					}
2814					&SerializeWith(&self.r#geo_covers)
2815				})?;
2816			} else {
2817				serialize_struct.skip_field("geoCovers")?;
2818			}
2819			if !Vec::is_empty(&self.r#geo_crosses) {
2820				serialize_struct.serialize_field("geoCrosses", {
2821					struct SerializeWith<'a>(&'a Vec<GeoCrossesProperty>);
2822					impl<'a> Serialize for SerializeWith<'a> {
2823						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2824						where
2825							S: Serializer,
2826						{
2827							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2828								self.0, serializer,
2829							)
2830						}
2831					}
2832					&SerializeWith(&self.r#geo_crosses)
2833				})?;
2834			} else {
2835				serialize_struct.skip_field("geoCrosses")?;
2836			}
2837			if !Vec::is_empty(&self.r#geo_disjoint) {
2838				serialize_struct.serialize_field("geoDisjoint", {
2839					struct SerializeWith<'a>(&'a Vec<GeoDisjointProperty>);
2840					impl<'a> Serialize for SerializeWith<'a> {
2841						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2842						where
2843							S: Serializer,
2844						{
2845							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2846								self.0, serializer,
2847							)
2848						}
2849					}
2850					&SerializeWith(&self.r#geo_disjoint)
2851				})?;
2852			} else {
2853				serialize_struct.skip_field("geoDisjoint")?;
2854			}
2855			if !Vec::is_empty(&self.r#geo_equals) {
2856				serialize_struct.serialize_field("geoEquals", {
2857					struct SerializeWith<'a>(&'a Vec<GeoEqualsProperty>);
2858					impl<'a> Serialize for SerializeWith<'a> {
2859						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2860						where
2861							S: Serializer,
2862						{
2863							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2864								self.0, serializer,
2865							)
2866						}
2867					}
2868					&SerializeWith(&self.r#geo_equals)
2869				})?;
2870			} else {
2871				serialize_struct.skip_field("geoEquals")?;
2872			}
2873			if !Vec::is_empty(&self.r#geo_intersects) {
2874				serialize_struct.serialize_field("geoIntersects", {
2875					struct SerializeWith<'a>(&'a Vec<GeoIntersectsProperty>);
2876					impl<'a> Serialize for SerializeWith<'a> {
2877						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2878						where
2879							S: Serializer,
2880						{
2881							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2882								self.0, serializer,
2883							)
2884						}
2885					}
2886					&SerializeWith(&self.r#geo_intersects)
2887				})?;
2888			} else {
2889				serialize_struct.skip_field("geoIntersects")?;
2890			}
2891			if !Vec::is_empty(&self.r#geo_overlaps) {
2892				serialize_struct.serialize_field("geoOverlaps", {
2893					struct SerializeWith<'a>(&'a Vec<GeoOverlapsProperty>);
2894					impl<'a> Serialize for SerializeWith<'a> {
2895						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2896						where
2897							S: Serializer,
2898						{
2899							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2900								self.0, serializer,
2901							)
2902						}
2903					}
2904					&SerializeWith(&self.r#geo_overlaps)
2905				})?;
2906			} else {
2907				serialize_struct.skip_field("geoOverlaps")?;
2908			}
2909			if !Vec::is_empty(&self.r#geo_touches) {
2910				serialize_struct.serialize_field("geoTouches", {
2911					struct SerializeWith<'a>(&'a Vec<GeoTouchesProperty>);
2912					impl<'a> Serialize for SerializeWith<'a> {
2913						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2914						where
2915							S: Serializer,
2916						{
2917							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2918								self.0, serializer,
2919							)
2920						}
2921					}
2922					&SerializeWith(&self.r#geo_touches)
2923				})?;
2924			} else {
2925				serialize_struct.skip_field("geoTouches")?;
2926			}
2927			if !Vec::is_empty(&self.r#geo_within) {
2928				serialize_struct.serialize_field("geoWithin", {
2929					struct SerializeWith<'a>(&'a Vec<GeoWithinProperty>);
2930					impl<'a> Serialize for SerializeWith<'a> {
2931						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2932						where
2933							S: Serializer,
2934						{
2935							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2936								self.0, serializer,
2937							)
2938						}
2939					}
2940					&SerializeWith(&self.r#geo_within)
2941				})?;
2942			} else {
2943				serialize_struct.skip_field("geoWithin")?;
2944			}
2945			if !Vec::is_empty(&self.r#has_drive_through_service) {
2946				serialize_struct.serialize_field("hasDriveThroughService", {
2947					struct SerializeWith<'a>(&'a Vec<HasDriveThroughServiceProperty>);
2948					impl<'a> Serialize for SerializeWith<'a> {
2949						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2950						where
2951							S: Serializer,
2952						{
2953							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2954								self.0, serializer,
2955							)
2956						}
2957					}
2958					&SerializeWith(&self.r#has_drive_through_service)
2959				})?;
2960			} else {
2961				serialize_struct.skip_field("hasDriveThroughService")?;
2962			}
2963			if !Vec::is_empty(&self.r#has_map) {
2964				serialize_struct.serialize_field("hasMap", {
2965					struct SerializeWith<'a>(&'a Vec<HasMapProperty>);
2966					impl<'a> Serialize for SerializeWith<'a> {
2967						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2968						where
2969							S: Serializer,
2970						{
2971							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2972								self.0, serializer,
2973							)
2974						}
2975					}
2976					&SerializeWith(&self.r#has_map)
2977				})?;
2978			} else {
2979				serialize_struct.skip_field("hasMap")?;
2980			}
2981			if !Vec::is_empty(&self.r#is_accessible_for_free) {
2982				serialize_struct.serialize_field("isAccessibleForFree", {
2983					struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
2984					impl<'a> Serialize for SerializeWith<'a> {
2985						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2986						where
2987							S: Serializer,
2988						{
2989							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2990								self.0, serializer,
2991							)
2992						}
2993					}
2994					&SerializeWith(&self.r#is_accessible_for_free)
2995				})?;
2996			} else {
2997				serialize_struct.skip_field("isAccessibleForFree")?;
2998			}
2999			if !Vec::is_empty(&self.r#latitude) {
3000				serialize_struct.serialize_field("latitude", {
3001					struct SerializeWith<'a>(&'a Vec<LatitudeProperty>);
3002					impl<'a> Serialize for SerializeWith<'a> {
3003						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3004						where
3005							S: Serializer,
3006						{
3007							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3008								self.0, serializer,
3009							)
3010						}
3011					}
3012					&SerializeWith(&self.r#latitude)
3013				})?;
3014			} else {
3015				serialize_struct.skip_field("latitude")?;
3016			}
3017			if !Vec::is_empty(&self.r#longitude) {
3018				serialize_struct.serialize_field("longitude", {
3019					struct SerializeWith<'a>(&'a Vec<LongitudeProperty>);
3020					impl<'a> Serialize for SerializeWith<'a> {
3021						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3022						where
3023							S: Serializer,
3024						{
3025							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3026								self.0, serializer,
3027							)
3028						}
3029					}
3030					&SerializeWith(&self.r#longitude)
3031				})?;
3032			} else {
3033				serialize_struct.skip_field("longitude")?;
3034			}
3035			if !Vec::is_empty(&self.r#map) {
3036				serialize_struct.serialize_field("map", {
3037					struct SerializeWith<'a>(&'a Vec<MapProperty>);
3038					impl<'a> Serialize for SerializeWith<'a> {
3039						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3040						where
3041							S: Serializer,
3042						{
3043							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3044								self.0, serializer,
3045							)
3046						}
3047					}
3048					&SerializeWith(&self.r#map)
3049				})?;
3050			} else {
3051				serialize_struct.skip_field("map")?;
3052			}
3053			if !Vec::is_empty(&self.r#maps) {
3054				serialize_struct.serialize_field("maps", {
3055					struct SerializeWith<'a>(&'a Vec<MapsProperty>);
3056					impl<'a> Serialize for SerializeWith<'a> {
3057						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3058						where
3059							S: Serializer,
3060						{
3061							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3062								self.0, serializer,
3063							)
3064						}
3065					}
3066					&SerializeWith(&self.r#maps)
3067				})?;
3068			} else {
3069				serialize_struct.skip_field("maps")?;
3070			}
3071			if !Vec::is_empty(&self.r#maximum_attendee_capacity) {
3072				serialize_struct.serialize_field("maximumAttendeeCapacity", {
3073					struct SerializeWith<'a>(&'a Vec<MaximumAttendeeCapacityProperty>);
3074					impl<'a> Serialize for SerializeWith<'a> {
3075						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3076						where
3077							S: Serializer,
3078						{
3079							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3080								self.0, serializer,
3081							)
3082						}
3083					}
3084					&SerializeWith(&self.r#maximum_attendee_capacity)
3085				})?;
3086			} else {
3087				serialize_struct.skip_field("maximumAttendeeCapacity")?;
3088			}
3089			if !Vec::is_empty(&self.r#opening_hours_specification) {
3090				serialize_struct.serialize_field("openingHoursSpecification", {
3091					struct SerializeWith<'a>(&'a Vec<OpeningHoursSpecificationProperty>);
3092					impl<'a> Serialize for SerializeWith<'a> {
3093						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3094						where
3095							S: Serializer,
3096						{
3097							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3098								self.0, serializer,
3099							)
3100						}
3101					}
3102					&SerializeWith(&self.r#opening_hours_specification)
3103				})?;
3104			} else {
3105				serialize_struct.skip_field("openingHoursSpecification")?;
3106			}
3107			if !Vec::is_empty(&self.r#photo) {
3108				serialize_struct.serialize_field("photo", {
3109					struct SerializeWith<'a>(&'a Vec<PhotoProperty>);
3110					impl<'a> Serialize for SerializeWith<'a> {
3111						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3112						where
3113							S: Serializer,
3114						{
3115							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3116								self.0, serializer,
3117							)
3118						}
3119					}
3120					&SerializeWith(&self.r#photo)
3121				})?;
3122			} else {
3123				serialize_struct.skip_field("photo")?;
3124			}
3125			if !Vec::is_empty(&self.r#photos) {
3126				serialize_struct.serialize_field("photos", {
3127					struct SerializeWith<'a>(&'a Vec<PhotosProperty>);
3128					impl<'a> Serialize for SerializeWith<'a> {
3129						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3130						where
3131							S: Serializer,
3132						{
3133							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3134								self.0, serializer,
3135							)
3136						}
3137					}
3138					&SerializeWith(&self.r#photos)
3139				})?;
3140			} else {
3141				serialize_struct.skip_field("photos")?;
3142			}
3143			if !Vec::is_empty(&self.r#public_access) {
3144				serialize_struct.serialize_field("publicAccess", {
3145					struct SerializeWith<'a>(&'a Vec<PublicAccessProperty>);
3146					impl<'a> Serialize for SerializeWith<'a> {
3147						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3148						where
3149							S: Serializer,
3150						{
3151							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3152								self.0, serializer,
3153							)
3154						}
3155					}
3156					&SerializeWith(&self.r#public_access)
3157				})?;
3158			} else {
3159				serialize_struct.skip_field("publicAccess")?;
3160			}
3161			if !Vec::is_empty(&self.r#smoking_allowed) {
3162				serialize_struct.serialize_field("smokingAllowed", {
3163					struct SerializeWith<'a>(&'a Vec<SmokingAllowedProperty>);
3164					impl<'a> Serialize for SerializeWith<'a> {
3165						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3166						where
3167							S: Serializer,
3168						{
3169							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3170								self.0, serializer,
3171							)
3172						}
3173					}
3174					&SerializeWith(&self.r#smoking_allowed)
3175				})?;
3176			} else {
3177				serialize_struct.skip_field("smokingAllowed")?;
3178			}
3179			if !Vec::is_empty(&self.r#special_opening_hours_specification) {
3180				serialize_struct.serialize_field("specialOpeningHoursSpecification", {
3181					struct SerializeWith<'a>(&'a Vec<SpecialOpeningHoursSpecificationProperty>);
3182					impl<'a> Serialize for SerializeWith<'a> {
3183						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3184						where
3185							S: Serializer,
3186						{
3187							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3188								self.0, serializer,
3189							)
3190						}
3191					}
3192					&SerializeWith(&self.r#special_opening_hours_specification)
3193				})?;
3194			} else {
3195				serialize_struct.skip_field("specialOpeningHoursSpecification")?;
3196			}
3197			if !Vec::is_empty(&self.r#tour_booking_page) {
3198				serialize_struct.serialize_field("tourBookingPage", {
3199					struct SerializeWith<'a>(&'a Vec<TourBookingPageProperty>);
3200					impl<'a> Serialize for SerializeWith<'a> {
3201						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3202						where
3203							S: Serializer,
3204						{
3205							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3206								self.0, serializer,
3207							)
3208						}
3209					}
3210					&SerializeWith(&self.r#tour_booking_page)
3211				})?;
3212			} else {
3213				serialize_struct.skip_field("tourBookingPage")?;
3214			}
3215			if !Vec::is_empty(&self.r#additional_type) {
3216				serialize_struct.serialize_field("additionalType", {
3217					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
3218					impl<'a> Serialize for SerializeWith<'a> {
3219						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3220						where
3221							S: Serializer,
3222						{
3223							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3224								self.0, serializer,
3225							)
3226						}
3227					}
3228					&SerializeWith(&self.r#additional_type)
3229				})?;
3230			} else {
3231				serialize_struct.skip_field("additionalType")?;
3232			}
3233			if !Vec::is_empty(&self.r#alternate_name) {
3234				serialize_struct.serialize_field("alternateName", {
3235					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
3236					impl<'a> Serialize for SerializeWith<'a> {
3237						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3238						where
3239							S: Serializer,
3240						{
3241							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3242								self.0, serializer,
3243							)
3244						}
3245					}
3246					&SerializeWith(&self.r#alternate_name)
3247				})?;
3248			} else {
3249				serialize_struct.skip_field("alternateName")?;
3250			}
3251			if !Vec::is_empty(&self.r#description) {
3252				serialize_struct.serialize_field("description", {
3253					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
3254					impl<'a> Serialize for SerializeWith<'a> {
3255						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3256						where
3257							S: Serializer,
3258						{
3259							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3260								self.0, serializer,
3261							)
3262						}
3263					}
3264					&SerializeWith(&self.r#description)
3265				})?;
3266			} else {
3267				serialize_struct.skip_field("description")?;
3268			}
3269			if !Vec::is_empty(&self.r#disambiguating_description) {
3270				serialize_struct.serialize_field("disambiguatingDescription", {
3271					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
3272					impl<'a> Serialize for SerializeWith<'a> {
3273						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3274						where
3275							S: Serializer,
3276						{
3277							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3278								self.0, serializer,
3279							)
3280						}
3281					}
3282					&SerializeWith(&self.r#disambiguating_description)
3283				})?;
3284			} else {
3285				serialize_struct.skip_field("disambiguatingDescription")?;
3286			}
3287			if !Vec::is_empty(&self.r#identifier) {
3288				serialize_struct.serialize_field("identifier", {
3289					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
3290					impl<'a> Serialize for SerializeWith<'a> {
3291						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3292						where
3293							S: Serializer,
3294						{
3295							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3296								self.0, serializer,
3297							)
3298						}
3299					}
3300					&SerializeWith(&self.r#identifier)
3301				})?;
3302			} else {
3303				serialize_struct.skip_field("identifier")?;
3304			}
3305			if !Vec::is_empty(&self.r#image) {
3306				serialize_struct.serialize_field("image", {
3307					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
3308					impl<'a> Serialize for SerializeWith<'a> {
3309						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3310						where
3311							S: Serializer,
3312						{
3313							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3314								self.0, serializer,
3315							)
3316						}
3317					}
3318					&SerializeWith(&self.r#image)
3319				})?;
3320			} else {
3321				serialize_struct.skip_field("image")?;
3322			}
3323			if !Vec::is_empty(&self.r#main_entity_of_page) {
3324				serialize_struct.serialize_field("mainEntityOfPage", {
3325					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
3326					impl<'a> Serialize for SerializeWith<'a> {
3327						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3328						where
3329							S: Serializer,
3330						{
3331							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3332								self.0, serializer,
3333							)
3334						}
3335					}
3336					&SerializeWith(&self.r#main_entity_of_page)
3337				})?;
3338			} else {
3339				serialize_struct.skip_field("mainEntityOfPage")?;
3340			}
3341			if !Vec::is_empty(&self.r#name) {
3342				serialize_struct.serialize_field("name", {
3343					struct SerializeWith<'a>(&'a Vec<NameProperty>);
3344					impl<'a> Serialize for SerializeWith<'a> {
3345						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3346						where
3347							S: Serializer,
3348						{
3349							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3350								self.0, serializer,
3351							)
3352						}
3353					}
3354					&SerializeWith(&self.r#name)
3355				})?;
3356			} else {
3357				serialize_struct.skip_field("name")?;
3358			}
3359			if !Vec::is_empty(&self.r#potential_action) {
3360				serialize_struct.serialize_field("potentialAction", {
3361					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
3362					impl<'a> Serialize for SerializeWith<'a> {
3363						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3364						where
3365							S: Serializer,
3366						{
3367							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3368								self.0, serializer,
3369							)
3370						}
3371					}
3372					&SerializeWith(&self.r#potential_action)
3373				})?;
3374			} else {
3375				serialize_struct.skip_field("potentialAction")?;
3376			}
3377			if !Vec::is_empty(&self.r#same_as) {
3378				serialize_struct.serialize_field("sameAs", {
3379					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
3380					impl<'a> Serialize for SerializeWith<'a> {
3381						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3382						where
3383							S: Serializer,
3384						{
3385							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3386								self.0, serializer,
3387							)
3388						}
3389					}
3390					&SerializeWith(&self.r#same_as)
3391				})?;
3392			} else {
3393				serialize_struct.skip_field("sameAs")?;
3394			}
3395			if !Vec::is_empty(&self.r#subject_of) {
3396				serialize_struct.serialize_field("subjectOf", {
3397					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
3398					impl<'a> Serialize for SerializeWith<'a> {
3399						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3400						where
3401							S: Serializer,
3402						{
3403							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3404								self.0, serializer,
3405							)
3406						}
3407					}
3408					&SerializeWith(&self.r#subject_of)
3409				})?;
3410			} else {
3411				serialize_struct.skip_field("subjectOf")?;
3412			}
3413			if !Vec::is_empty(&self.r#url) {
3414				serialize_struct.serialize_field("url", {
3415					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
3416					impl<'a> Serialize for SerializeWith<'a> {
3417						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3418						where
3419							S: Serializer,
3420						{
3421							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3422								self.0, serializer,
3423							)
3424						}
3425					}
3426					&SerializeWith(&self.r#url)
3427				})?;
3428			} else {
3429				serialize_struct.skip_field("url")?;
3430			}
3431			serialize_struct.end()
3432		}
3433	}
3434	impl<'de> Deserialize<'de> for IceCreamShop {
3435		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3436		where
3437			D: Deserializer<'de>,
3438		{
3439			enum Field {
3440				AcceptsReservations,
3441				HasMenu,
3442				Menu,
3443				ServesCuisine,
3444				StarRating,
3445				BranchOf,
3446				CurrenciesAccepted,
3447				OpeningHours,
3448				PaymentAccepted,
3449				PriceRange,
3450				ActionableFeedbackPolicy,
3451				Address,
3452				AgentInteractionStatistic,
3453				AggregateRating,
3454				Alumni,
3455				AreaServed,
3456				Award,
3457				Awards,
3458				Brand,
3459				ContactPoint,
3460				ContactPoints,
3461				CorrectionsPolicy,
3462				Department,
3463				DissolutionDate,
3464				DiversityPolicy,
3465				DiversityStaffingReport,
3466				Duns,
3467				Email,
3468				Employee,
3469				Employees,
3470				EthicsPolicy,
3471				Event,
3472				Events,
3473				FaxNumber,
3474				Founder,
3475				Founders,
3476				FoundingDate,
3477				FoundingLocation,
3478				Funder,
3479				Funding,
3480				GlobalLocationNumber,
3481				HasCredential,
3482				HasMerchantReturnPolicy,
3483				HasOfferCatalog,
3484				HasPos,
3485				HasProductReturnPolicy,
3486				InteractionStatistic,
3487				IsicV4,
3488				Iso6523Code,
3489				Keywords,
3490				KnowsAbout,
3491				KnowsLanguage,
3492				LegalName,
3493				LeiCode,
3494				Location,
3495				Logo,
3496				MakesOffer,
3497				Member,
3498				MemberOf,
3499				Members,
3500				Naics,
3501				NonprofitStatus,
3502				NumberOfEmployees,
3503				OwnershipFundingInfo,
3504				Owns,
3505				ParentOrganization,
3506				PublishingPrinciples,
3507				Review,
3508				Reviews,
3509				Seeks,
3510				ServiceArea,
3511				Slogan,
3512				Sponsor,
3513				SubOrganization,
3514				TaxId,
3515				Telephone,
3516				UnnamedSourcesPolicy,
3517				VatId,
3518				AdditionalProperty,
3519				AmenityFeature,
3520				BranchCode,
3521				ContainedIn,
3522				ContainedInPlace,
3523				ContainsPlace,
3524				Geo,
3525				GeoContains,
3526				GeoCoveredBy,
3527				GeoCovers,
3528				GeoCrosses,
3529				GeoDisjoint,
3530				GeoEquals,
3531				GeoIntersects,
3532				GeoOverlaps,
3533				GeoTouches,
3534				GeoWithin,
3535				HasDriveThroughService,
3536				HasMap,
3537				IsAccessibleForFree,
3538				Latitude,
3539				Longitude,
3540				Map,
3541				Maps,
3542				MaximumAttendeeCapacity,
3543				OpeningHoursSpecification,
3544				Photo,
3545				Photos,
3546				PublicAccess,
3547				SmokingAllowed,
3548				SpecialOpeningHoursSpecification,
3549				TourBookingPage,
3550				AdditionalType,
3551				AlternateName,
3552				Description,
3553				DisambiguatingDescription,
3554				Identifier,
3555				Image,
3556				MainEntityOfPage,
3557				Name,
3558				PotentialAction,
3559				SameAs,
3560				SubjectOf,
3561				Url,
3562				Ignore,
3563			}
3564			struct FieldVisitor;
3565			impl<'de> Visitor<'de> for FieldVisitor {
3566				type Value = Field;
3567				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
3568					formatter.write_str("field identifier")
3569				}
3570				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
3571				where
3572					E: de::Error,
3573				{
3574					match value {
3575						"acceptsReservations" => Ok(Field::AcceptsReservations),
3576						"hasMenu" => Ok(Field::HasMenu),
3577						"menu" => Ok(Field::Menu),
3578						"servesCuisine" => Ok(Field::ServesCuisine),
3579						"starRating" => Ok(Field::StarRating),
3580						"branchOf" => Ok(Field::BranchOf),
3581						"currenciesAccepted" => Ok(Field::CurrenciesAccepted),
3582						"openingHours" => Ok(Field::OpeningHours),
3583						"paymentAccepted" => Ok(Field::PaymentAccepted),
3584						"priceRange" => Ok(Field::PriceRange),
3585						"actionableFeedbackPolicy" => Ok(Field::ActionableFeedbackPolicy),
3586						"address" => Ok(Field::Address),
3587						"agentInteractionStatistic" => Ok(Field::AgentInteractionStatistic),
3588						"aggregateRating" => Ok(Field::AggregateRating),
3589						"alumni" => Ok(Field::Alumni),
3590						"areaServed" => Ok(Field::AreaServed),
3591						"award" => Ok(Field::Award),
3592						"awards" => Ok(Field::Awards),
3593						"brand" => Ok(Field::Brand),
3594						"contactPoint" => Ok(Field::ContactPoint),
3595						"contactPoints" => Ok(Field::ContactPoints),
3596						"correctionsPolicy" => Ok(Field::CorrectionsPolicy),
3597						"department" => Ok(Field::Department),
3598						"dissolutionDate" => Ok(Field::DissolutionDate),
3599						"diversityPolicy" => Ok(Field::DiversityPolicy),
3600						"diversityStaffingReport" => Ok(Field::DiversityStaffingReport),
3601						"duns" => Ok(Field::Duns),
3602						"email" => Ok(Field::Email),
3603						"employee" => Ok(Field::Employee),
3604						"employees" => Ok(Field::Employees),
3605						"ethicsPolicy" => Ok(Field::EthicsPolicy),
3606						"event" => Ok(Field::Event),
3607						"events" => Ok(Field::Events),
3608						"faxNumber" => Ok(Field::FaxNumber),
3609						"founder" => Ok(Field::Founder),
3610						"founders" => Ok(Field::Founders),
3611						"foundingDate" => Ok(Field::FoundingDate),
3612						"foundingLocation" => Ok(Field::FoundingLocation),
3613						"funder" => Ok(Field::Funder),
3614						"funding" => Ok(Field::Funding),
3615						"globalLocationNumber" => Ok(Field::GlobalLocationNumber),
3616						"hasCredential" => Ok(Field::HasCredential),
3617						"hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
3618						"hasOfferCatalog" => Ok(Field::HasOfferCatalog),
3619						"hasPOS" => Ok(Field::HasPos),
3620						"hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
3621						"interactionStatistic" => Ok(Field::InteractionStatistic),
3622						"isicV4" => Ok(Field::IsicV4),
3623						"iso6523Code" => Ok(Field::Iso6523Code),
3624						"keywords" => Ok(Field::Keywords),
3625						"knowsAbout" => Ok(Field::KnowsAbout),
3626						"knowsLanguage" => Ok(Field::KnowsLanguage),
3627						"legalName" => Ok(Field::LegalName),
3628						"leiCode" => Ok(Field::LeiCode),
3629						"location" => Ok(Field::Location),
3630						"logo" => Ok(Field::Logo),
3631						"makesOffer" => Ok(Field::MakesOffer),
3632						"member" => Ok(Field::Member),
3633						"memberOf" => Ok(Field::MemberOf),
3634						"members" => Ok(Field::Members),
3635						"naics" => Ok(Field::Naics),
3636						"nonprofitStatus" => Ok(Field::NonprofitStatus),
3637						"numberOfEmployees" => Ok(Field::NumberOfEmployees),
3638						"ownershipFundingInfo" => Ok(Field::OwnershipFundingInfo),
3639						"owns" => Ok(Field::Owns),
3640						"parentOrganization" => Ok(Field::ParentOrganization),
3641						"publishingPrinciples" => Ok(Field::PublishingPrinciples),
3642						"review" => Ok(Field::Review),
3643						"reviews" => Ok(Field::Reviews),
3644						"seeks" => Ok(Field::Seeks),
3645						"serviceArea" => Ok(Field::ServiceArea),
3646						"slogan" => Ok(Field::Slogan),
3647						"sponsor" => Ok(Field::Sponsor),
3648						"subOrganization" => Ok(Field::SubOrganization),
3649						"taxID" => Ok(Field::TaxId),
3650						"telephone" => Ok(Field::Telephone),
3651						"unnamedSourcesPolicy" => Ok(Field::UnnamedSourcesPolicy),
3652						"vatID" => Ok(Field::VatId),
3653						"additionalProperty" => Ok(Field::AdditionalProperty),
3654						"amenityFeature" => Ok(Field::AmenityFeature),
3655						"branchCode" => Ok(Field::BranchCode),
3656						"containedIn" => Ok(Field::ContainedIn),
3657						"containedInPlace" => Ok(Field::ContainedInPlace),
3658						"containsPlace" => Ok(Field::ContainsPlace),
3659						"geo" => Ok(Field::Geo),
3660						"geoContains" => Ok(Field::GeoContains),
3661						"geoCoveredBy" => Ok(Field::GeoCoveredBy),
3662						"geoCovers" => Ok(Field::GeoCovers),
3663						"geoCrosses" => Ok(Field::GeoCrosses),
3664						"geoDisjoint" => Ok(Field::GeoDisjoint),
3665						"geoEquals" => Ok(Field::GeoEquals),
3666						"geoIntersects" => Ok(Field::GeoIntersects),
3667						"geoOverlaps" => Ok(Field::GeoOverlaps),
3668						"geoTouches" => Ok(Field::GeoTouches),
3669						"geoWithin" => Ok(Field::GeoWithin),
3670						"hasDriveThroughService" => Ok(Field::HasDriveThroughService),
3671						"hasMap" => Ok(Field::HasMap),
3672						"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
3673						"latitude" => Ok(Field::Latitude),
3674						"longitude" => Ok(Field::Longitude),
3675						"map" => Ok(Field::Map),
3676						"maps" => Ok(Field::Maps),
3677						"maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
3678						"openingHoursSpecification" => Ok(Field::OpeningHoursSpecification),
3679						"photo" => Ok(Field::Photo),
3680						"photos" => Ok(Field::Photos),
3681						"publicAccess" => Ok(Field::PublicAccess),
3682						"smokingAllowed" => Ok(Field::SmokingAllowed),
3683						"specialOpeningHoursSpecification" => {
3684							Ok(Field::SpecialOpeningHoursSpecification)
3685						}
3686						"tourBookingPage" => Ok(Field::TourBookingPage),
3687						"additionalType" => Ok(Field::AdditionalType),
3688						"alternateName" => Ok(Field::AlternateName),
3689						"description" => Ok(Field::Description),
3690						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
3691						"identifier" => Ok(Field::Identifier),
3692						"image" => Ok(Field::Image),
3693						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
3694						"name" => Ok(Field::Name),
3695						"potentialAction" => Ok(Field::PotentialAction),
3696						"sameAs" => Ok(Field::SameAs),
3697						"subjectOf" => Ok(Field::SubjectOf),
3698						"url" => Ok(Field::Url),
3699						"id" | "type" => Ok(Field::Ignore),
3700						_ => Err(de::Error::unknown_field(value, FIELDS)),
3701					}
3702				}
3703				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
3704				where
3705					E: de::Error,
3706				{
3707					match value {
3708						b"acceptsReservations" => Ok(Field::AcceptsReservations),
3709						b"hasMenu" => Ok(Field::HasMenu),
3710						b"menu" => Ok(Field::Menu),
3711						b"servesCuisine" => Ok(Field::ServesCuisine),
3712						b"starRating" => Ok(Field::StarRating),
3713						b"branchOf" => Ok(Field::BranchOf),
3714						b"currenciesAccepted" => Ok(Field::CurrenciesAccepted),
3715						b"openingHours" => Ok(Field::OpeningHours),
3716						b"paymentAccepted" => Ok(Field::PaymentAccepted),
3717						b"priceRange" => Ok(Field::PriceRange),
3718						b"actionableFeedbackPolicy" => Ok(Field::ActionableFeedbackPolicy),
3719						b"address" => Ok(Field::Address),
3720						b"agentInteractionStatistic" => Ok(Field::AgentInteractionStatistic),
3721						b"aggregateRating" => Ok(Field::AggregateRating),
3722						b"alumni" => Ok(Field::Alumni),
3723						b"areaServed" => Ok(Field::AreaServed),
3724						b"award" => Ok(Field::Award),
3725						b"awards" => Ok(Field::Awards),
3726						b"brand" => Ok(Field::Brand),
3727						b"contactPoint" => Ok(Field::ContactPoint),
3728						b"contactPoints" => Ok(Field::ContactPoints),
3729						b"correctionsPolicy" => Ok(Field::CorrectionsPolicy),
3730						b"department" => Ok(Field::Department),
3731						b"dissolutionDate" => Ok(Field::DissolutionDate),
3732						b"diversityPolicy" => Ok(Field::DiversityPolicy),
3733						b"diversityStaffingReport" => Ok(Field::DiversityStaffingReport),
3734						b"duns" => Ok(Field::Duns),
3735						b"email" => Ok(Field::Email),
3736						b"employee" => Ok(Field::Employee),
3737						b"employees" => Ok(Field::Employees),
3738						b"ethicsPolicy" => Ok(Field::EthicsPolicy),
3739						b"event" => Ok(Field::Event),
3740						b"events" => Ok(Field::Events),
3741						b"faxNumber" => Ok(Field::FaxNumber),
3742						b"founder" => Ok(Field::Founder),
3743						b"founders" => Ok(Field::Founders),
3744						b"foundingDate" => Ok(Field::FoundingDate),
3745						b"foundingLocation" => Ok(Field::FoundingLocation),
3746						b"funder" => Ok(Field::Funder),
3747						b"funding" => Ok(Field::Funding),
3748						b"globalLocationNumber" => Ok(Field::GlobalLocationNumber),
3749						b"hasCredential" => Ok(Field::HasCredential),
3750						b"hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
3751						b"hasOfferCatalog" => Ok(Field::HasOfferCatalog),
3752						b"hasPOS" => Ok(Field::HasPos),
3753						b"hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
3754						b"interactionStatistic" => Ok(Field::InteractionStatistic),
3755						b"isicV4" => Ok(Field::IsicV4),
3756						b"iso6523Code" => Ok(Field::Iso6523Code),
3757						b"keywords" => Ok(Field::Keywords),
3758						b"knowsAbout" => Ok(Field::KnowsAbout),
3759						b"knowsLanguage" => Ok(Field::KnowsLanguage),
3760						b"legalName" => Ok(Field::LegalName),
3761						b"leiCode" => Ok(Field::LeiCode),
3762						b"location" => Ok(Field::Location),
3763						b"logo" => Ok(Field::Logo),
3764						b"makesOffer" => Ok(Field::MakesOffer),
3765						b"member" => Ok(Field::Member),
3766						b"memberOf" => Ok(Field::MemberOf),
3767						b"members" => Ok(Field::Members),
3768						b"naics" => Ok(Field::Naics),
3769						b"nonprofitStatus" => Ok(Field::NonprofitStatus),
3770						b"numberOfEmployees" => Ok(Field::NumberOfEmployees),
3771						b"ownershipFundingInfo" => Ok(Field::OwnershipFundingInfo),
3772						b"owns" => Ok(Field::Owns),
3773						b"parentOrganization" => Ok(Field::ParentOrganization),
3774						b"publishingPrinciples" => Ok(Field::PublishingPrinciples),
3775						b"review" => Ok(Field::Review),
3776						b"reviews" => Ok(Field::Reviews),
3777						b"seeks" => Ok(Field::Seeks),
3778						b"serviceArea" => Ok(Field::ServiceArea),
3779						b"slogan" => Ok(Field::Slogan),
3780						b"sponsor" => Ok(Field::Sponsor),
3781						b"subOrganization" => Ok(Field::SubOrganization),
3782						b"taxID" => Ok(Field::TaxId),
3783						b"telephone" => Ok(Field::Telephone),
3784						b"unnamedSourcesPolicy" => Ok(Field::UnnamedSourcesPolicy),
3785						b"vatID" => Ok(Field::VatId),
3786						b"additionalProperty" => Ok(Field::AdditionalProperty),
3787						b"amenityFeature" => Ok(Field::AmenityFeature),
3788						b"branchCode" => Ok(Field::BranchCode),
3789						b"containedIn" => Ok(Field::ContainedIn),
3790						b"containedInPlace" => Ok(Field::ContainedInPlace),
3791						b"containsPlace" => Ok(Field::ContainsPlace),
3792						b"geo" => Ok(Field::Geo),
3793						b"geoContains" => Ok(Field::GeoContains),
3794						b"geoCoveredBy" => Ok(Field::GeoCoveredBy),
3795						b"geoCovers" => Ok(Field::GeoCovers),
3796						b"geoCrosses" => Ok(Field::GeoCrosses),
3797						b"geoDisjoint" => Ok(Field::GeoDisjoint),
3798						b"geoEquals" => Ok(Field::GeoEquals),
3799						b"geoIntersects" => Ok(Field::GeoIntersects),
3800						b"geoOverlaps" => Ok(Field::GeoOverlaps),
3801						b"geoTouches" => Ok(Field::GeoTouches),
3802						b"geoWithin" => Ok(Field::GeoWithin),
3803						b"hasDriveThroughService" => Ok(Field::HasDriveThroughService),
3804						b"hasMap" => Ok(Field::HasMap),
3805						b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
3806						b"latitude" => Ok(Field::Latitude),
3807						b"longitude" => Ok(Field::Longitude),
3808						b"map" => Ok(Field::Map),
3809						b"maps" => Ok(Field::Maps),
3810						b"maximumAttendeeCapacity" => Ok(Field::MaximumAttendeeCapacity),
3811						b"openingHoursSpecification" => Ok(Field::OpeningHoursSpecification),
3812						b"photo" => Ok(Field::Photo),
3813						b"photos" => Ok(Field::Photos),
3814						b"publicAccess" => Ok(Field::PublicAccess),
3815						b"smokingAllowed" => Ok(Field::SmokingAllowed),
3816						b"specialOpeningHoursSpecification" => {
3817							Ok(Field::SpecialOpeningHoursSpecification)
3818						}
3819						b"tourBookingPage" => Ok(Field::TourBookingPage),
3820						b"additionalType" => Ok(Field::AdditionalType),
3821						b"alternateName" => Ok(Field::AlternateName),
3822						b"description" => Ok(Field::Description),
3823						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
3824						b"identifier" => Ok(Field::Identifier),
3825						b"image" => Ok(Field::Image),
3826						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
3827						b"name" => Ok(Field::Name),
3828						b"potentialAction" => Ok(Field::PotentialAction),
3829						b"sameAs" => Ok(Field::SameAs),
3830						b"subjectOf" => Ok(Field::SubjectOf),
3831						b"url" => Ok(Field::Url),
3832						b"id" | b"type" => Ok(Field::Ignore),
3833						_ => {
3834							let value = &String::from_utf8_lossy(value);
3835							Err(de::Error::unknown_field(value, FIELDS))
3836						}
3837					}
3838				}
3839			}
3840			impl<'de> Deserialize<'de> for Field {
3841				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3842				where
3843					D: Deserializer<'de>,
3844				{
3845					deserializer.deserialize_identifier(FieldVisitor)
3846				}
3847			}
3848			struct ClassVisitor;
3849			impl<'de> Visitor<'de> for ClassVisitor {
3850				type Value = IceCreamShop;
3851				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
3852					formatter.write_str("schema.org schema IceCreamShop")
3853				}
3854				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
3855				where
3856					A: de::MapAccess<'de>,
3857				{
3858					let mut r#accepts_reservations_property = None;
3859					let mut r#has_menu_property = None;
3860					let mut r#menu_property = None;
3861					let mut r#serves_cuisine_property = None;
3862					let mut r#star_rating_property = None;
3863					let mut r#branch_of_property = None;
3864					let mut r#currencies_accepted_property = None;
3865					let mut r#opening_hours_property = None;
3866					let mut r#payment_accepted_property = None;
3867					let mut r#price_range_property = None;
3868					let mut r#actionable_feedback_policy_property = None;
3869					let mut r#address_property = None;
3870					let mut r#agent_interaction_statistic_property = None;
3871					let mut r#aggregate_rating_property = None;
3872					let mut r#alumni_property = None;
3873					let mut r#area_served_property = None;
3874					let mut r#award_property = None;
3875					let mut r#awards_property = None;
3876					let mut r#brand_property = None;
3877					let mut r#contact_point_property = None;
3878					let mut r#contact_points_property = None;
3879					let mut r#corrections_policy_property = None;
3880					let mut r#department_property = None;
3881					let mut r#dissolution_date_property = None;
3882					let mut r#diversity_policy_property = None;
3883					let mut r#diversity_staffing_report_property = None;
3884					let mut r#duns_property = None;
3885					let mut r#email_property = None;
3886					let mut r#employee_property = None;
3887					let mut r#employees_property = None;
3888					let mut r#ethics_policy_property = None;
3889					let mut r#event_property = None;
3890					let mut r#events_property = None;
3891					let mut r#fax_number_property = None;
3892					let mut r#founder_property = None;
3893					let mut r#founders_property = None;
3894					let mut r#founding_date_property = None;
3895					let mut r#founding_location_property = None;
3896					let mut r#funder_property = None;
3897					let mut r#funding_property = None;
3898					let mut r#global_location_number_property = None;
3899					let mut r#has_credential_property = None;
3900					let mut r#has_merchant_return_policy_property = None;
3901					let mut r#has_offer_catalog_property = None;
3902					let mut r#has_pos_property = None;
3903					let mut r#has_product_return_policy_property = None;
3904					let mut r#interaction_statistic_property = None;
3905					let mut r#isic_v_4_property = None;
3906					let mut r#iso_6523_code_property = None;
3907					let mut r#keywords_property = None;
3908					let mut r#knows_about_property = None;
3909					let mut r#knows_language_property = None;
3910					let mut r#legal_name_property = None;
3911					let mut r#lei_code_property = None;
3912					let mut r#location_property = None;
3913					let mut r#logo_property = None;
3914					let mut r#makes_offer_property = None;
3915					let mut r#member_property = None;
3916					let mut r#member_of_property = None;
3917					let mut r#members_property = None;
3918					let mut r#naics_property = None;
3919					let mut r#nonprofit_status_property = None;
3920					let mut r#number_of_employees_property = None;
3921					let mut r#ownership_funding_info_property = None;
3922					let mut r#owns_property = None;
3923					let mut r#parent_organization_property = None;
3924					let mut r#publishing_principles_property = None;
3925					let mut r#review_property = None;
3926					let mut r#reviews_property = None;
3927					let mut r#seeks_property = None;
3928					let mut r#service_area_property = None;
3929					let mut r#slogan_property = None;
3930					let mut r#sponsor_property = None;
3931					let mut r#sub_organization_property = None;
3932					let mut r#tax_id_property = None;
3933					let mut r#telephone_property = None;
3934					let mut r#unnamed_sources_policy_property = None;
3935					let mut r#vat_id_property = None;
3936					let mut r#additional_property_property = None;
3937					let mut r#amenity_feature_property = None;
3938					let mut r#branch_code_property = None;
3939					let mut r#contained_in_property = None;
3940					let mut r#contained_in_place_property = None;
3941					let mut r#contains_place_property = None;
3942					let mut r#geo_property = None;
3943					let mut r#geo_contains_property = None;
3944					let mut r#geo_covered_by_property = None;
3945					let mut r#geo_covers_property = None;
3946					let mut r#geo_crosses_property = None;
3947					let mut r#geo_disjoint_property = None;
3948					let mut r#geo_equals_property = None;
3949					let mut r#geo_intersects_property = None;
3950					let mut r#geo_overlaps_property = None;
3951					let mut r#geo_touches_property = None;
3952					let mut r#geo_within_property = None;
3953					let mut r#has_drive_through_service_property = None;
3954					let mut r#has_map_property = None;
3955					let mut r#is_accessible_for_free_property = None;
3956					let mut r#latitude_property = None;
3957					let mut r#longitude_property = None;
3958					let mut r#map_property = None;
3959					let mut r#maps_property = None;
3960					let mut r#maximum_attendee_capacity_property = None;
3961					let mut r#opening_hours_specification_property = None;
3962					let mut r#photo_property = None;
3963					let mut r#photos_property = None;
3964					let mut r#public_access_property = None;
3965					let mut r#smoking_allowed_property = None;
3966					let mut r#special_opening_hours_specification_property = None;
3967					let mut r#tour_booking_page_property = None;
3968					let mut r#additional_type_property = None;
3969					let mut r#alternate_name_property = None;
3970					let mut r#description_property = None;
3971					let mut r#disambiguating_description_property = None;
3972					let mut r#identifier_property = None;
3973					let mut r#image_property = None;
3974					let mut r#main_entity_of_page_property = None;
3975					let mut r#name_property = None;
3976					let mut r#potential_action_property = None;
3977					let mut r#same_as_property = None;
3978					let mut r#subject_of_property = None;
3979					let mut r#url_property = None;
3980					while let Some(key) = map.next_key::<Field>()? {
3981						match key {
3982							Field::AcceptsReservations => {
3983								if r#accepts_reservations_property.is_some() {
3984									return Err(<A::Error as de::Error>::duplicate_field(
3985										"acceptsReservations",
3986									));
3987								}
3988								r#accepts_reservations_property = Some({
3989									struct DeserializeWith(Vec<AcceptsReservationsProperty>);
3990									impl<'de> Deserialize<'de> for DeserializeWith {
3991										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3992										where
3993											D: Deserializer<'de>,
3994										{
3995											Ok(DeserializeWith(serde_with::As::<
3996												serde_with::OneOrMany<serde_with::Same>,
3997											>::deserialize(deserializer)?))
3998										}
3999									}
4000									match map.next_value::<DeserializeWith>() {
4001										Ok(deserialize_with) => deserialize_with.0,
4002										Err(err) => {
4003											return Err(err);
4004										}
4005									}
4006								});
4007							}
4008							Field::HasMenu => {
4009								if r#has_menu_property.is_some() {
4010									return Err(<A::Error as de::Error>::duplicate_field(
4011										"hasMenu",
4012									));
4013								}
4014								r#has_menu_property = Some({
4015									struct DeserializeWith(Vec<HasMenuProperty>);
4016									impl<'de> Deserialize<'de> for DeserializeWith {
4017										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4018										where
4019											D: Deserializer<'de>,
4020										{
4021											Ok(DeserializeWith(serde_with::As::<
4022												serde_with::OneOrMany<serde_with::Same>,
4023											>::deserialize(deserializer)?))
4024										}
4025									}
4026									match map.next_value::<DeserializeWith>() {
4027										Ok(deserialize_with) => deserialize_with.0,
4028										Err(err) => {
4029											return Err(err);
4030										}
4031									}
4032								});
4033							}
4034							Field::Menu => {
4035								if r#menu_property.is_some() {
4036									return Err(<A::Error as de::Error>::duplicate_field("menu"));
4037								}
4038								r#menu_property = Some({
4039									struct DeserializeWith(Vec<MenuProperty>);
4040									impl<'de> Deserialize<'de> for DeserializeWith {
4041										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4042										where
4043											D: Deserializer<'de>,
4044										{
4045											Ok(DeserializeWith(serde_with::As::<
4046												serde_with::OneOrMany<serde_with::Same>,
4047											>::deserialize(deserializer)?))
4048										}
4049									}
4050									match map.next_value::<DeserializeWith>() {
4051										Ok(deserialize_with) => deserialize_with.0,
4052										Err(err) => {
4053											return Err(err);
4054										}
4055									}
4056								});
4057							}
4058							Field::ServesCuisine => {
4059								if r#serves_cuisine_property.is_some() {
4060									return Err(<A::Error as de::Error>::duplicate_field(
4061										"servesCuisine",
4062									));
4063								}
4064								r#serves_cuisine_property = Some({
4065									struct DeserializeWith(Vec<ServesCuisineProperty>);
4066									impl<'de> Deserialize<'de> for DeserializeWith {
4067										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4068										where
4069											D: Deserializer<'de>,
4070										{
4071											Ok(DeserializeWith(serde_with::As::<
4072												serde_with::OneOrMany<serde_with::Same>,
4073											>::deserialize(deserializer)?))
4074										}
4075									}
4076									match map.next_value::<DeserializeWith>() {
4077										Ok(deserialize_with) => deserialize_with.0,
4078										Err(err) => {
4079											return Err(err);
4080										}
4081									}
4082								});
4083							}
4084							Field::StarRating => {
4085								if r#star_rating_property.is_some() {
4086									return Err(<A::Error as de::Error>::duplicate_field(
4087										"starRating",
4088									));
4089								}
4090								r#star_rating_property = Some({
4091									struct DeserializeWith(Vec<StarRatingProperty>);
4092									impl<'de> Deserialize<'de> for DeserializeWith {
4093										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4094										where
4095											D: Deserializer<'de>,
4096										{
4097											Ok(DeserializeWith(serde_with::As::<
4098												serde_with::OneOrMany<serde_with::Same>,
4099											>::deserialize(deserializer)?))
4100										}
4101									}
4102									match map.next_value::<DeserializeWith>() {
4103										Ok(deserialize_with) => deserialize_with.0,
4104										Err(err) => {
4105											return Err(err);
4106										}
4107									}
4108								});
4109							}
4110							Field::BranchOf => {
4111								if r#branch_of_property.is_some() {
4112									return Err(<A::Error as de::Error>::duplicate_field(
4113										"branchOf",
4114									));
4115								}
4116								r#branch_of_property = Some({
4117									struct DeserializeWith(Vec<BranchOfProperty>);
4118									impl<'de> Deserialize<'de> for DeserializeWith {
4119										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4120										where
4121											D: Deserializer<'de>,
4122										{
4123											Ok(DeserializeWith(serde_with::As::<
4124												serde_with::OneOrMany<serde_with::Same>,
4125											>::deserialize(deserializer)?))
4126										}
4127									}
4128									match map.next_value::<DeserializeWith>() {
4129										Ok(deserialize_with) => deserialize_with.0,
4130										Err(err) => {
4131											return Err(err);
4132										}
4133									}
4134								});
4135							}
4136							Field::CurrenciesAccepted => {
4137								if r#currencies_accepted_property.is_some() {
4138									return Err(<A::Error as de::Error>::duplicate_field(
4139										"currenciesAccepted",
4140									));
4141								}
4142								r#currencies_accepted_property = Some({
4143									struct DeserializeWith(Vec<CurrenciesAcceptedProperty>);
4144									impl<'de> Deserialize<'de> for DeserializeWith {
4145										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4146										where
4147											D: Deserializer<'de>,
4148										{
4149											Ok(DeserializeWith(serde_with::As::<
4150												serde_with::OneOrMany<serde_with::Same>,
4151											>::deserialize(deserializer)?))
4152										}
4153									}
4154									match map.next_value::<DeserializeWith>() {
4155										Ok(deserialize_with) => deserialize_with.0,
4156										Err(err) => {
4157											return Err(err);
4158										}
4159									}
4160								});
4161							}
4162							Field::OpeningHours => {
4163								if r#opening_hours_property.is_some() {
4164									return Err(<A::Error as de::Error>::duplicate_field(
4165										"openingHours",
4166									));
4167								}
4168								r#opening_hours_property = Some({
4169									struct DeserializeWith(Vec<OpeningHoursProperty>);
4170									impl<'de> Deserialize<'de> for DeserializeWith {
4171										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4172										where
4173											D: Deserializer<'de>,
4174										{
4175											Ok(DeserializeWith(serde_with::As::<
4176												serde_with::OneOrMany<serde_with::Same>,
4177											>::deserialize(deserializer)?))
4178										}
4179									}
4180									match map.next_value::<DeserializeWith>() {
4181										Ok(deserialize_with) => deserialize_with.0,
4182										Err(err) => {
4183											return Err(err);
4184										}
4185									}
4186								});
4187							}
4188							Field::PaymentAccepted => {
4189								if r#payment_accepted_property.is_some() {
4190									return Err(<A::Error as de::Error>::duplicate_field(
4191										"paymentAccepted",
4192									));
4193								}
4194								r#payment_accepted_property = Some({
4195									struct DeserializeWith(Vec<PaymentAcceptedProperty>);
4196									impl<'de> Deserialize<'de> for DeserializeWith {
4197										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4198										where
4199											D: Deserializer<'de>,
4200										{
4201											Ok(DeserializeWith(serde_with::As::<
4202												serde_with::OneOrMany<serde_with::Same>,
4203											>::deserialize(deserializer)?))
4204										}
4205									}
4206									match map.next_value::<DeserializeWith>() {
4207										Ok(deserialize_with) => deserialize_with.0,
4208										Err(err) => {
4209											return Err(err);
4210										}
4211									}
4212								});
4213							}
4214							Field::PriceRange => {
4215								if r#price_range_property.is_some() {
4216									return Err(<A::Error as de::Error>::duplicate_field(
4217										"priceRange",
4218									));
4219								}
4220								r#price_range_property = Some({
4221									struct DeserializeWith(Vec<PriceRangeProperty>);
4222									impl<'de> Deserialize<'de> for DeserializeWith {
4223										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4224										where
4225											D: Deserializer<'de>,
4226										{
4227											Ok(DeserializeWith(serde_with::As::<
4228												serde_with::OneOrMany<serde_with::Same>,
4229											>::deserialize(deserializer)?))
4230										}
4231									}
4232									match map.next_value::<DeserializeWith>() {
4233										Ok(deserialize_with) => deserialize_with.0,
4234										Err(err) => {
4235											return Err(err);
4236										}
4237									}
4238								});
4239							}
4240							Field::ActionableFeedbackPolicy => {
4241								if r#actionable_feedback_policy_property.is_some() {
4242									return Err(<A::Error as de::Error>::duplicate_field(
4243										"actionableFeedbackPolicy",
4244									));
4245								}
4246								r#actionable_feedback_policy_property = Some({
4247									struct DeserializeWith(Vec<ActionableFeedbackPolicyProperty>);
4248									impl<'de> Deserialize<'de> for DeserializeWith {
4249										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4250										where
4251											D: Deserializer<'de>,
4252										{
4253											Ok(DeserializeWith(serde_with::As::<
4254												serde_with::OneOrMany<serde_with::Same>,
4255											>::deserialize(deserializer)?))
4256										}
4257									}
4258									match map.next_value::<DeserializeWith>() {
4259										Ok(deserialize_with) => deserialize_with.0,
4260										Err(err) => {
4261											return Err(err);
4262										}
4263									}
4264								});
4265							}
4266							Field::Address => {
4267								if r#address_property.is_some() {
4268									return Err(<A::Error as de::Error>::duplicate_field(
4269										"address",
4270									));
4271								}
4272								r#address_property = Some({
4273									struct DeserializeWith(Vec<AddressProperty>);
4274									impl<'de> Deserialize<'de> for DeserializeWith {
4275										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4276										where
4277											D: Deserializer<'de>,
4278										{
4279											Ok(DeserializeWith(serde_with::As::<
4280												serde_with::OneOrMany<serde_with::Same>,
4281											>::deserialize(deserializer)?))
4282										}
4283									}
4284									match map.next_value::<DeserializeWith>() {
4285										Ok(deserialize_with) => deserialize_with.0,
4286										Err(err) => {
4287											return Err(err);
4288										}
4289									}
4290								});
4291							}
4292							Field::AgentInteractionStatistic => {
4293								if r#agent_interaction_statistic_property.is_some() {
4294									return Err(<A::Error as de::Error>::duplicate_field(
4295										"agentInteractionStatistic",
4296									));
4297								}
4298								r#agent_interaction_statistic_property = Some({
4299									struct DeserializeWith(Vec<AgentInteractionStatisticProperty>);
4300									impl<'de> Deserialize<'de> for DeserializeWith {
4301										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4302										where
4303											D: Deserializer<'de>,
4304										{
4305											Ok(DeserializeWith(serde_with::As::<
4306												serde_with::OneOrMany<serde_with::Same>,
4307											>::deserialize(deserializer)?))
4308										}
4309									}
4310									match map.next_value::<DeserializeWith>() {
4311										Ok(deserialize_with) => deserialize_with.0,
4312										Err(err) => {
4313											return Err(err);
4314										}
4315									}
4316								});
4317							}
4318							Field::AggregateRating => {
4319								if r#aggregate_rating_property.is_some() {
4320									return Err(<A::Error as de::Error>::duplicate_field(
4321										"aggregateRating",
4322									));
4323								}
4324								r#aggregate_rating_property = Some({
4325									struct DeserializeWith(Vec<AggregateRatingProperty>);
4326									impl<'de> Deserialize<'de> for DeserializeWith {
4327										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4328										where
4329											D: Deserializer<'de>,
4330										{
4331											Ok(DeserializeWith(serde_with::As::<
4332												serde_with::OneOrMany<serde_with::Same>,
4333											>::deserialize(deserializer)?))
4334										}
4335									}
4336									match map.next_value::<DeserializeWith>() {
4337										Ok(deserialize_with) => deserialize_with.0,
4338										Err(err) => {
4339											return Err(err);
4340										}
4341									}
4342								});
4343							}
4344							Field::Alumni => {
4345								if r#alumni_property.is_some() {
4346									return Err(<A::Error as de::Error>::duplicate_field("alumni"));
4347								}
4348								r#alumni_property = Some({
4349									struct DeserializeWith(Vec<AlumniProperty>);
4350									impl<'de> Deserialize<'de> for DeserializeWith {
4351										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4352										where
4353											D: Deserializer<'de>,
4354										{
4355											Ok(DeserializeWith(serde_with::As::<
4356												serde_with::OneOrMany<serde_with::Same>,
4357											>::deserialize(deserializer)?))
4358										}
4359									}
4360									match map.next_value::<DeserializeWith>() {
4361										Ok(deserialize_with) => deserialize_with.0,
4362										Err(err) => {
4363											return Err(err);
4364										}
4365									}
4366								});
4367							}
4368							Field::AreaServed => {
4369								if r#area_served_property.is_some() {
4370									return Err(<A::Error as de::Error>::duplicate_field(
4371										"areaServed",
4372									));
4373								}
4374								r#area_served_property = Some({
4375									struct DeserializeWith(Vec<AreaServedProperty>);
4376									impl<'de> Deserialize<'de> for DeserializeWith {
4377										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4378										where
4379											D: Deserializer<'de>,
4380										{
4381											Ok(DeserializeWith(serde_with::As::<
4382												serde_with::OneOrMany<serde_with::Same>,
4383											>::deserialize(deserializer)?))
4384										}
4385									}
4386									match map.next_value::<DeserializeWith>() {
4387										Ok(deserialize_with) => deserialize_with.0,
4388										Err(err) => {
4389											return Err(err);
4390										}
4391									}
4392								});
4393							}
4394							Field::Award => {
4395								if r#award_property.is_some() {
4396									return Err(<A::Error as de::Error>::duplicate_field("award"));
4397								}
4398								r#award_property = Some({
4399									struct DeserializeWith(Vec<AwardProperty>);
4400									impl<'de> Deserialize<'de> for DeserializeWith {
4401										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4402										where
4403											D: Deserializer<'de>,
4404										{
4405											Ok(DeserializeWith(serde_with::As::<
4406												serde_with::OneOrMany<serde_with::Same>,
4407											>::deserialize(deserializer)?))
4408										}
4409									}
4410									match map.next_value::<DeserializeWith>() {
4411										Ok(deserialize_with) => deserialize_with.0,
4412										Err(err) => {
4413											return Err(err);
4414										}
4415									}
4416								});
4417							}
4418							Field::Awards => {
4419								if r#awards_property.is_some() {
4420									return Err(<A::Error as de::Error>::duplicate_field("awards"));
4421								}
4422								r#awards_property = Some({
4423									struct DeserializeWith(Vec<AwardsProperty>);
4424									impl<'de> Deserialize<'de> for DeserializeWith {
4425										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4426										where
4427											D: Deserializer<'de>,
4428										{
4429											Ok(DeserializeWith(serde_with::As::<
4430												serde_with::OneOrMany<serde_with::Same>,
4431											>::deserialize(deserializer)?))
4432										}
4433									}
4434									match map.next_value::<DeserializeWith>() {
4435										Ok(deserialize_with) => deserialize_with.0,
4436										Err(err) => {
4437											return Err(err);
4438										}
4439									}
4440								});
4441							}
4442							Field::Brand => {
4443								if r#brand_property.is_some() {
4444									return Err(<A::Error as de::Error>::duplicate_field("brand"));
4445								}
4446								r#brand_property = Some({
4447									struct DeserializeWith(Vec<BrandProperty>);
4448									impl<'de> Deserialize<'de> for DeserializeWith {
4449										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4450										where
4451											D: Deserializer<'de>,
4452										{
4453											Ok(DeserializeWith(serde_with::As::<
4454												serde_with::OneOrMany<serde_with::Same>,
4455											>::deserialize(deserializer)?))
4456										}
4457									}
4458									match map.next_value::<DeserializeWith>() {
4459										Ok(deserialize_with) => deserialize_with.0,
4460										Err(err) => {
4461											return Err(err);
4462										}
4463									}
4464								});
4465							}
4466							Field::ContactPoint => {
4467								if r#contact_point_property.is_some() {
4468									return Err(<A::Error as de::Error>::duplicate_field(
4469										"contactPoint",
4470									));
4471								}
4472								r#contact_point_property = Some({
4473									struct DeserializeWith(Vec<ContactPointProperty>);
4474									impl<'de> Deserialize<'de> for DeserializeWith {
4475										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4476										where
4477											D: Deserializer<'de>,
4478										{
4479											Ok(DeserializeWith(serde_with::As::<
4480												serde_with::OneOrMany<serde_with::Same>,
4481											>::deserialize(deserializer)?))
4482										}
4483									}
4484									match map.next_value::<DeserializeWith>() {
4485										Ok(deserialize_with) => deserialize_with.0,
4486										Err(err) => {
4487											return Err(err);
4488										}
4489									}
4490								});
4491							}
4492							Field::ContactPoints => {
4493								if r#contact_points_property.is_some() {
4494									return Err(<A::Error as de::Error>::duplicate_field(
4495										"contactPoints",
4496									));
4497								}
4498								r#contact_points_property = Some({
4499									struct DeserializeWith(Vec<ContactPointsProperty>);
4500									impl<'de> Deserialize<'de> for DeserializeWith {
4501										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4502										where
4503											D: Deserializer<'de>,
4504										{
4505											Ok(DeserializeWith(serde_with::As::<
4506												serde_with::OneOrMany<serde_with::Same>,
4507											>::deserialize(deserializer)?))
4508										}
4509									}
4510									match map.next_value::<DeserializeWith>() {
4511										Ok(deserialize_with) => deserialize_with.0,
4512										Err(err) => {
4513											return Err(err);
4514										}
4515									}
4516								});
4517							}
4518							Field::CorrectionsPolicy => {
4519								if r#corrections_policy_property.is_some() {
4520									return Err(<A::Error as de::Error>::duplicate_field(
4521										"correctionsPolicy",
4522									));
4523								}
4524								r#corrections_policy_property = Some({
4525									struct DeserializeWith(Vec<CorrectionsPolicyProperty>);
4526									impl<'de> Deserialize<'de> for DeserializeWith {
4527										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4528										where
4529											D: Deserializer<'de>,
4530										{
4531											Ok(DeserializeWith(serde_with::As::<
4532												serde_with::OneOrMany<serde_with::Same>,
4533											>::deserialize(deserializer)?))
4534										}
4535									}
4536									match map.next_value::<DeserializeWith>() {
4537										Ok(deserialize_with) => deserialize_with.0,
4538										Err(err) => {
4539											return Err(err);
4540										}
4541									}
4542								});
4543							}
4544							Field::Department => {
4545								if r#department_property.is_some() {
4546									return Err(<A::Error as de::Error>::duplicate_field(
4547										"department",
4548									));
4549								}
4550								r#department_property = Some({
4551									struct DeserializeWith(Vec<DepartmentProperty>);
4552									impl<'de> Deserialize<'de> for DeserializeWith {
4553										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4554										where
4555											D: Deserializer<'de>,
4556										{
4557											Ok(DeserializeWith(serde_with::As::<
4558												serde_with::OneOrMany<serde_with::Same>,
4559											>::deserialize(deserializer)?))
4560										}
4561									}
4562									match map.next_value::<DeserializeWith>() {
4563										Ok(deserialize_with) => deserialize_with.0,
4564										Err(err) => {
4565											return Err(err);
4566										}
4567									}
4568								});
4569							}
4570							Field::DissolutionDate => {
4571								if r#dissolution_date_property.is_some() {
4572									return Err(<A::Error as de::Error>::duplicate_field(
4573										"dissolutionDate",
4574									));
4575								}
4576								r#dissolution_date_property = Some({
4577									struct DeserializeWith(Vec<DissolutionDateProperty>);
4578									impl<'de> Deserialize<'de> for DeserializeWith {
4579										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4580										where
4581											D: Deserializer<'de>,
4582										{
4583											Ok(DeserializeWith(serde_with::As::<
4584												serde_with::OneOrMany<serde_with::Same>,
4585											>::deserialize(deserializer)?))
4586										}
4587									}
4588									match map.next_value::<DeserializeWith>() {
4589										Ok(deserialize_with) => deserialize_with.0,
4590										Err(err) => {
4591											return Err(err);
4592										}
4593									}
4594								});
4595							}
4596							Field::DiversityPolicy => {
4597								if r#diversity_policy_property.is_some() {
4598									return Err(<A::Error as de::Error>::duplicate_field(
4599										"diversityPolicy",
4600									));
4601								}
4602								r#diversity_policy_property = Some({
4603									struct DeserializeWith(Vec<DiversityPolicyProperty>);
4604									impl<'de> Deserialize<'de> for DeserializeWith {
4605										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4606										where
4607											D: Deserializer<'de>,
4608										{
4609											Ok(DeserializeWith(serde_with::As::<
4610												serde_with::OneOrMany<serde_with::Same>,
4611											>::deserialize(deserializer)?))
4612										}
4613									}
4614									match map.next_value::<DeserializeWith>() {
4615										Ok(deserialize_with) => deserialize_with.0,
4616										Err(err) => {
4617											return Err(err);
4618										}
4619									}
4620								});
4621							}
4622							Field::DiversityStaffingReport => {
4623								if r#diversity_staffing_report_property.is_some() {
4624									return Err(<A::Error as de::Error>::duplicate_field(
4625										"diversityStaffingReport",
4626									));
4627								}
4628								r#diversity_staffing_report_property = Some({
4629									struct DeserializeWith(Vec<DiversityStaffingReportProperty>);
4630									impl<'de> Deserialize<'de> for DeserializeWith {
4631										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4632										where
4633											D: Deserializer<'de>,
4634										{
4635											Ok(DeserializeWith(serde_with::As::<
4636												serde_with::OneOrMany<serde_with::Same>,
4637											>::deserialize(deserializer)?))
4638										}
4639									}
4640									match map.next_value::<DeserializeWith>() {
4641										Ok(deserialize_with) => deserialize_with.0,
4642										Err(err) => {
4643											return Err(err);
4644										}
4645									}
4646								});
4647							}
4648							Field::Duns => {
4649								if r#duns_property.is_some() {
4650									return Err(<A::Error as de::Error>::duplicate_field("duns"));
4651								}
4652								r#duns_property = Some({
4653									struct DeserializeWith(Vec<DunsProperty>);
4654									impl<'de> Deserialize<'de> for DeserializeWith {
4655										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4656										where
4657											D: Deserializer<'de>,
4658										{
4659											Ok(DeserializeWith(serde_with::As::<
4660												serde_with::OneOrMany<serde_with::Same>,
4661											>::deserialize(deserializer)?))
4662										}
4663									}
4664									match map.next_value::<DeserializeWith>() {
4665										Ok(deserialize_with) => deserialize_with.0,
4666										Err(err) => {
4667											return Err(err);
4668										}
4669									}
4670								});
4671							}
4672							Field::Email => {
4673								if r#email_property.is_some() {
4674									return Err(<A::Error as de::Error>::duplicate_field("email"));
4675								}
4676								r#email_property = Some({
4677									struct DeserializeWith(Vec<EmailProperty>);
4678									impl<'de> Deserialize<'de> for DeserializeWith {
4679										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4680										where
4681											D: Deserializer<'de>,
4682										{
4683											Ok(DeserializeWith(serde_with::As::<
4684												serde_with::OneOrMany<serde_with::Same>,
4685											>::deserialize(deserializer)?))
4686										}
4687									}
4688									match map.next_value::<DeserializeWith>() {
4689										Ok(deserialize_with) => deserialize_with.0,
4690										Err(err) => {
4691											return Err(err);
4692										}
4693									}
4694								});
4695							}
4696							Field::Employee => {
4697								if r#employee_property.is_some() {
4698									return Err(<A::Error as de::Error>::duplicate_field(
4699										"employee",
4700									));
4701								}
4702								r#employee_property = Some({
4703									struct DeserializeWith(Vec<EmployeeProperty>);
4704									impl<'de> Deserialize<'de> for DeserializeWith {
4705										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4706										where
4707											D: Deserializer<'de>,
4708										{
4709											Ok(DeserializeWith(serde_with::As::<
4710												serde_with::OneOrMany<serde_with::Same>,
4711											>::deserialize(deserializer)?))
4712										}
4713									}
4714									match map.next_value::<DeserializeWith>() {
4715										Ok(deserialize_with) => deserialize_with.0,
4716										Err(err) => {
4717											return Err(err);
4718										}
4719									}
4720								});
4721							}
4722							Field::Employees => {
4723								if r#employees_property.is_some() {
4724									return Err(<A::Error as de::Error>::duplicate_field(
4725										"employees",
4726									));
4727								}
4728								r#employees_property = Some({
4729									struct DeserializeWith(Vec<EmployeesProperty>);
4730									impl<'de> Deserialize<'de> for DeserializeWith {
4731										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4732										where
4733											D: Deserializer<'de>,
4734										{
4735											Ok(DeserializeWith(serde_with::As::<
4736												serde_with::OneOrMany<serde_with::Same>,
4737											>::deserialize(deserializer)?))
4738										}
4739									}
4740									match map.next_value::<DeserializeWith>() {
4741										Ok(deserialize_with) => deserialize_with.0,
4742										Err(err) => {
4743											return Err(err);
4744										}
4745									}
4746								});
4747							}
4748							Field::EthicsPolicy => {
4749								if r#ethics_policy_property.is_some() {
4750									return Err(<A::Error as de::Error>::duplicate_field(
4751										"ethicsPolicy",
4752									));
4753								}
4754								r#ethics_policy_property = Some({
4755									struct DeserializeWith(Vec<EthicsPolicyProperty>);
4756									impl<'de> Deserialize<'de> for DeserializeWith {
4757										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4758										where
4759											D: Deserializer<'de>,
4760										{
4761											Ok(DeserializeWith(serde_with::As::<
4762												serde_with::OneOrMany<serde_with::Same>,
4763											>::deserialize(deserializer)?))
4764										}
4765									}
4766									match map.next_value::<DeserializeWith>() {
4767										Ok(deserialize_with) => deserialize_with.0,
4768										Err(err) => {
4769											return Err(err);
4770										}
4771									}
4772								});
4773							}
4774							Field::Event => {
4775								if r#event_property.is_some() {
4776									return Err(<A::Error as de::Error>::duplicate_field("event"));
4777								}
4778								r#event_property = Some({
4779									struct DeserializeWith(Vec<EventProperty>);
4780									impl<'de> Deserialize<'de> for DeserializeWith {
4781										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4782										where
4783											D: Deserializer<'de>,
4784										{
4785											Ok(DeserializeWith(serde_with::As::<
4786												serde_with::OneOrMany<serde_with::Same>,
4787											>::deserialize(deserializer)?))
4788										}
4789									}
4790									match map.next_value::<DeserializeWith>() {
4791										Ok(deserialize_with) => deserialize_with.0,
4792										Err(err) => {
4793											return Err(err);
4794										}
4795									}
4796								});
4797							}
4798							Field::Events => {
4799								if r#events_property.is_some() {
4800									return Err(<A::Error as de::Error>::duplicate_field("events"));
4801								}
4802								r#events_property = Some({
4803									struct DeserializeWith(Vec<EventsProperty>);
4804									impl<'de> Deserialize<'de> for DeserializeWith {
4805										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4806										where
4807											D: Deserializer<'de>,
4808										{
4809											Ok(DeserializeWith(serde_with::As::<
4810												serde_with::OneOrMany<serde_with::Same>,
4811											>::deserialize(deserializer)?))
4812										}
4813									}
4814									match map.next_value::<DeserializeWith>() {
4815										Ok(deserialize_with) => deserialize_with.0,
4816										Err(err) => {
4817											return Err(err);
4818										}
4819									}
4820								});
4821							}
4822							Field::FaxNumber => {
4823								if r#fax_number_property.is_some() {
4824									return Err(<A::Error as de::Error>::duplicate_field(
4825										"faxNumber",
4826									));
4827								}
4828								r#fax_number_property = Some({
4829									struct DeserializeWith(Vec<FaxNumberProperty>);
4830									impl<'de> Deserialize<'de> for DeserializeWith {
4831										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4832										where
4833											D: Deserializer<'de>,
4834										{
4835											Ok(DeserializeWith(serde_with::As::<
4836												serde_with::OneOrMany<serde_with::Same>,
4837											>::deserialize(deserializer)?))
4838										}
4839									}
4840									match map.next_value::<DeserializeWith>() {
4841										Ok(deserialize_with) => deserialize_with.0,
4842										Err(err) => {
4843											return Err(err);
4844										}
4845									}
4846								});
4847							}
4848							Field::Founder => {
4849								if r#founder_property.is_some() {
4850									return Err(<A::Error as de::Error>::duplicate_field(
4851										"founder",
4852									));
4853								}
4854								r#founder_property = Some({
4855									struct DeserializeWith(Vec<FounderProperty>);
4856									impl<'de> Deserialize<'de> for DeserializeWith {
4857										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4858										where
4859											D: Deserializer<'de>,
4860										{
4861											Ok(DeserializeWith(serde_with::As::<
4862												serde_with::OneOrMany<serde_with::Same>,
4863											>::deserialize(deserializer)?))
4864										}
4865									}
4866									match map.next_value::<DeserializeWith>() {
4867										Ok(deserialize_with) => deserialize_with.0,
4868										Err(err) => {
4869											return Err(err);
4870										}
4871									}
4872								});
4873							}
4874							Field::Founders => {
4875								if r#founders_property.is_some() {
4876									return Err(<A::Error as de::Error>::duplicate_field(
4877										"founders",
4878									));
4879								}
4880								r#founders_property = Some({
4881									struct DeserializeWith(Vec<FoundersProperty>);
4882									impl<'de> Deserialize<'de> for DeserializeWith {
4883										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4884										where
4885											D: Deserializer<'de>,
4886										{
4887											Ok(DeserializeWith(serde_with::As::<
4888												serde_with::OneOrMany<serde_with::Same>,
4889											>::deserialize(deserializer)?))
4890										}
4891									}
4892									match map.next_value::<DeserializeWith>() {
4893										Ok(deserialize_with) => deserialize_with.0,
4894										Err(err) => {
4895											return Err(err);
4896										}
4897									}
4898								});
4899							}
4900							Field::FoundingDate => {
4901								if r#founding_date_property.is_some() {
4902									return Err(<A::Error as de::Error>::duplicate_field(
4903										"foundingDate",
4904									));
4905								}
4906								r#founding_date_property = Some({
4907									struct DeserializeWith(Vec<FoundingDateProperty>);
4908									impl<'de> Deserialize<'de> for DeserializeWith {
4909										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4910										where
4911											D: Deserializer<'de>,
4912										{
4913											Ok(DeserializeWith(serde_with::As::<
4914												serde_with::OneOrMany<serde_with::Same>,
4915											>::deserialize(deserializer)?))
4916										}
4917									}
4918									match map.next_value::<DeserializeWith>() {
4919										Ok(deserialize_with) => deserialize_with.0,
4920										Err(err) => {
4921											return Err(err);
4922										}
4923									}
4924								});
4925							}
4926							Field::FoundingLocation => {
4927								if r#founding_location_property.is_some() {
4928									return Err(<A::Error as de::Error>::duplicate_field(
4929										"foundingLocation",
4930									));
4931								}
4932								r#founding_location_property = Some({
4933									struct DeserializeWith(Vec<FoundingLocationProperty>);
4934									impl<'de> Deserialize<'de> for DeserializeWith {
4935										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4936										where
4937											D: Deserializer<'de>,
4938										{
4939											Ok(DeserializeWith(serde_with::As::<
4940												serde_with::OneOrMany<serde_with::Same>,
4941											>::deserialize(deserializer)?))
4942										}
4943									}
4944									match map.next_value::<DeserializeWith>() {
4945										Ok(deserialize_with) => deserialize_with.0,
4946										Err(err) => {
4947											return Err(err);
4948										}
4949									}
4950								});
4951							}
4952							Field::Funder => {
4953								if r#funder_property.is_some() {
4954									return Err(<A::Error as de::Error>::duplicate_field("funder"));
4955								}
4956								r#funder_property = Some({
4957									struct DeserializeWith(Vec<FunderProperty>);
4958									impl<'de> Deserialize<'de> for DeserializeWith {
4959										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4960										where
4961											D: Deserializer<'de>,
4962										{
4963											Ok(DeserializeWith(serde_with::As::<
4964												serde_with::OneOrMany<serde_with::Same>,
4965											>::deserialize(deserializer)?))
4966										}
4967									}
4968									match map.next_value::<DeserializeWith>() {
4969										Ok(deserialize_with) => deserialize_with.0,
4970										Err(err) => {
4971											return Err(err);
4972										}
4973									}
4974								});
4975							}
4976							Field::Funding => {
4977								if r#funding_property.is_some() {
4978									return Err(<A::Error as de::Error>::duplicate_field(
4979										"funding",
4980									));
4981								}
4982								r#funding_property = Some({
4983									struct DeserializeWith(Vec<FundingProperty>);
4984									impl<'de> Deserialize<'de> for DeserializeWith {
4985										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4986										where
4987											D: Deserializer<'de>,
4988										{
4989											Ok(DeserializeWith(serde_with::As::<
4990												serde_with::OneOrMany<serde_with::Same>,
4991											>::deserialize(deserializer)?))
4992										}
4993									}
4994									match map.next_value::<DeserializeWith>() {
4995										Ok(deserialize_with) => deserialize_with.0,
4996										Err(err) => {
4997											return Err(err);
4998										}
4999									}
5000								});
5001							}
5002							Field::GlobalLocationNumber => {
5003								if r#global_location_number_property.is_some() {
5004									return Err(<A::Error as de::Error>::duplicate_field(
5005										"globalLocationNumber",
5006									));
5007								}
5008								r#global_location_number_property = Some({
5009									struct DeserializeWith(Vec<GlobalLocationNumberProperty>);
5010									impl<'de> Deserialize<'de> for DeserializeWith {
5011										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5012										where
5013											D: Deserializer<'de>,
5014										{
5015											Ok(DeserializeWith(serde_with::As::<
5016												serde_with::OneOrMany<serde_with::Same>,
5017											>::deserialize(deserializer)?))
5018										}
5019									}
5020									match map.next_value::<DeserializeWith>() {
5021										Ok(deserialize_with) => deserialize_with.0,
5022										Err(err) => {
5023											return Err(err);
5024										}
5025									}
5026								});
5027							}
5028							Field::HasCredential => {
5029								if r#has_credential_property.is_some() {
5030									return Err(<A::Error as de::Error>::duplicate_field(
5031										"hasCredential",
5032									));
5033								}
5034								r#has_credential_property = Some({
5035									struct DeserializeWith(Vec<HasCredentialProperty>);
5036									impl<'de> Deserialize<'de> for DeserializeWith {
5037										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5038										where
5039											D: Deserializer<'de>,
5040										{
5041											Ok(DeserializeWith(serde_with::As::<
5042												serde_with::OneOrMany<serde_with::Same>,
5043											>::deserialize(deserializer)?))
5044										}
5045									}
5046									match map.next_value::<DeserializeWith>() {
5047										Ok(deserialize_with) => deserialize_with.0,
5048										Err(err) => {
5049											return Err(err);
5050										}
5051									}
5052								});
5053							}
5054							Field::HasMerchantReturnPolicy => {
5055								if r#has_merchant_return_policy_property.is_some() {
5056									return Err(<A::Error as de::Error>::duplicate_field(
5057										"hasMerchantReturnPolicy",
5058									));
5059								}
5060								r#has_merchant_return_policy_property = Some({
5061									struct DeserializeWith(Vec<HasMerchantReturnPolicyProperty>);
5062									impl<'de> Deserialize<'de> for DeserializeWith {
5063										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5064										where
5065											D: Deserializer<'de>,
5066										{
5067											Ok(DeserializeWith(serde_with::As::<
5068												serde_with::OneOrMany<serde_with::Same>,
5069											>::deserialize(deserializer)?))
5070										}
5071									}
5072									match map.next_value::<DeserializeWith>() {
5073										Ok(deserialize_with) => deserialize_with.0,
5074										Err(err) => {
5075											return Err(err);
5076										}
5077									}
5078								});
5079							}
5080							Field::HasOfferCatalog => {
5081								if r#has_offer_catalog_property.is_some() {
5082									return Err(<A::Error as de::Error>::duplicate_field(
5083										"hasOfferCatalog",
5084									));
5085								}
5086								r#has_offer_catalog_property = Some({
5087									struct DeserializeWith(Vec<HasOfferCatalogProperty>);
5088									impl<'de> Deserialize<'de> for DeserializeWith {
5089										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5090										where
5091											D: Deserializer<'de>,
5092										{
5093											Ok(DeserializeWith(serde_with::As::<
5094												serde_with::OneOrMany<serde_with::Same>,
5095											>::deserialize(deserializer)?))
5096										}
5097									}
5098									match map.next_value::<DeserializeWith>() {
5099										Ok(deserialize_with) => deserialize_with.0,
5100										Err(err) => {
5101											return Err(err);
5102										}
5103									}
5104								});
5105							}
5106							Field::HasPos => {
5107								if r#has_pos_property.is_some() {
5108									return Err(<A::Error as de::Error>::duplicate_field("hasPOS"));
5109								}
5110								r#has_pos_property = Some({
5111									struct DeserializeWith(Vec<HasPosProperty>);
5112									impl<'de> Deserialize<'de> for DeserializeWith {
5113										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5114										where
5115											D: Deserializer<'de>,
5116										{
5117											Ok(DeserializeWith(serde_with::As::<
5118												serde_with::OneOrMany<serde_with::Same>,
5119											>::deserialize(deserializer)?))
5120										}
5121									}
5122									match map.next_value::<DeserializeWith>() {
5123										Ok(deserialize_with) => deserialize_with.0,
5124										Err(err) => {
5125											return Err(err);
5126										}
5127									}
5128								});
5129							}
5130							Field::HasProductReturnPolicy => {
5131								if r#has_product_return_policy_property.is_some() {
5132									return Err(<A::Error as de::Error>::duplicate_field(
5133										"hasProductReturnPolicy",
5134									));
5135								}
5136								r#has_product_return_policy_property = Some({
5137									struct DeserializeWith(Vec<HasProductReturnPolicyProperty>);
5138									impl<'de> Deserialize<'de> for DeserializeWith {
5139										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5140										where
5141											D: Deserializer<'de>,
5142										{
5143											Ok(DeserializeWith(serde_with::As::<
5144												serde_with::OneOrMany<serde_with::Same>,
5145											>::deserialize(deserializer)?))
5146										}
5147									}
5148									match map.next_value::<DeserializeWith>() {
5149										Ok(deserialize_with) => deserialize_with.0,
5150										Err(err) => {
5151											return Err(err);
5152										}
5153									}
5154								});
5155							}
5156							Field::InteractionStatistic => {
5157								if r#interaction_statistic_property.is_some() {
5158									return Err(<A::Error as de::Error>::duplicate_field(
5159										"interactionStatistic",
5160									));
5161								}
5162								r#interaction_statistic_property = Some({
5163									struct DeserializeWith(Vec<InteractionStatisticProperty>);
5164									impl<'de> Deserialize<'de> for DeserializeWith {
5165										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5166										where
5167											D: Deserializer<'de>,
5168										{
5169											Ok(DeserializeWith(serde_with::As::<
5170												serde_with::OneOrMany<serde_with::Same>,
5171											>::deserialize(deserializer)?))
5172										}
5173									}
5174									match map.next_value::<DeserializeWith>() {
5175										Ok(deserialize_with) => deserialize_with.0,
5176										Err(err) => {
5177											return Err(err);
5178										}
5179									}
5180								});
5181							}
5182							Field::IsicV4 => {
5183								if r#isic_v_4_property.is_some() {
5184									return Err(<A::Error as de::Error>::duplicate_field("isicV4"));
5185								}
5186								r#isic_v_4_property = Some({
5187									struct DeserializeWith(Vec<IsicV4Property>);
5188									impl<'de> Deserialize<'de> for DeserializeWith {
5189										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5190										where
5191											D: Deserializer<'de>,
5192										{
5193											Ok(DeserializeWith(serde_with::As::<
5194												serde_with::OneOrMany<serde_with::Same>,
5195											>::deserialize(deserializer)?))
5196										}
5197									}
5198									match map.next_value::<DeserializeWith>() {
5199										Ok(deserialize_with) => deserialize_with.0,
5200										Err(err) => {
5201											return Err(err);
5202										}
5203									}
5204								});
5205							}
5206							Field::Iso6523Code => {
5207								if r#iso_6523_code_property.is_some() {
5208									return Err(<A::Error as de::Error>::duplicate_field(
5209										"iso6523Code",
5210									));
5211								}
5212								r#iso_6523_code_property = Some({
5213									struct DeserializeWith(Vec<Iso6523CodeProperty>);
5214									impl<'de> Deserialize<'de> for DeserializeWith {
5215										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5216										where
5217											D: Deserializer<'de>,
5218										{
5219											Ok(DeserializeWith(serde_with::As::<
5220												serde_with::OneOrMany<serde_with::Same>,
5221											>::deserialize(deserializer)?))
5222										}
5223									}
5224									match map.next_value::<DeserializeWith>() {
5225										Ok(deserialize_with) => deserialize_with.0,
5226										Err(err) => {
5227											return Err(err);
5228										}
5229									}
5230								});
5231							}
5232							Field::Keywords => {
5233								if r#keywords_property.is_some() {
5234									return Err(<A::Error as de::Error>::duplicate_field(
5235										"keywords",
5236									));
5237								}
5238								r#keywords_property = Some({
5239									struct DeserializeWith(Vec<KeywordsProperty>);
5240									impl<'de> Deserialize<'de> for DeserializeWith {
5241										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5242										where
5243											D: Deserializer<'de>,
5244										{
5245											Ok(DeserializeWith(serde_with::As::<
5246												serde_with::OneOrMany<serde_with::Same>,
5247											>::deserialize(deserializer)?))
5248										}
5249									}
5250									match map.next_value::<DeserializeWith>() {
5251										Ok(deserialize_with) => deserialize_with.0,
5252										Err(err) => {
5253											return Err(err);
5254										}
5255									}
5256								});
5257							}
5258							Field::KnowsAbout => {
5259								if r#knows_about_property.is_some() {
5260									return Err(<A::Error as de::Error>::duplicate_field(
5261										"knowsAbout",
5262									));
5263								}
5264								r#knows_about_property = Some({
5265									struct DeserializeWith(Vec<KnowsAboutProperty>);
5266									impl<'de> Deserialize<'de> for DeserializeWith {
5267										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5268										where
5269											D: Deserializer<'de>,
5270										{
5271											Ok(DeserializeWith(serde_with::As::<
5272												serde_with::OneOrMany<serde_with::Same>,
5273											>::deserialize(deserializer)?))
5274										}
5275									}
5276									match map.next_value::<DeserializeWith>() {
5277										Ok(deserialize_with) => deserialize_with.0,
5278										Err(err) => {
5279											return Err(err);
5280										}
5281									}
5282								});
5283							}
5284							Field::KnowsLanguage => {
5285								if r#knows_language_property.is_some() {
5286									return Err(<A::Error as de::Error>::duplicate_field(
5287										"knowsLanguage",
5288									));
5289								}
5290								r#knows_language_property = Some({
5291									struct DeserializeWith(Vec<KnowsLanguageProperty>);
5292									impl<'de> Deserialize<'de> for DeserializeWith {
5293										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5294										where
5295											D: Deserializer<'de>,
5296										{
5297											Ok(DeserializeWith(serde_with::As::<
5298												serde_with::OneOrMany<serde_with::Same>,
5299											>::deserialize(deserializer)?))
5300										}
5301									}
5302									match map.next_value::<DeserializeWith>() {
5303										Ok(deserialize_with) => deserialize_with.0,
5304										Err(err) => {
5305											return Err(err);
5306										}
5307									}
5308								});
5309							}
5310							Field::LegalName => {
5311								if r#legal_name_property.is_some() {
5312									return Err(<A::Error as de::Error>::duplicate_field(
5313										"legalName",
5314									));
5315								}
5316								r#legal_name_property = Some({
5317									struct DeserializeWith(Vec<LegalNameProperty>);
5318									impl<'de> Deserialize<'de> for DeserializeWith {
5319										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5320										where
5321											D: Deserializer<'de>,
5322										{
5323											Ok(DeserializeWith(serde_with::As::<
5324												serde_with::OneOrMany<serde_with::Same>,
5325											>::deserialize(deserializer)?))
5326										}
5327									}
5328									match map.next_value::<DeserializeWith>() {
5329										Ok(deserialize_with) => deserialize_with.0,
5330										Err(err) => {
5331											return Err(err);
5332										}
5333									}
5334								});
5335							}
5336							Field::LeiCode => {
5337								if r#lei_code_property.is_some() {
5338									return Err(<A::Error as de::Error>::duplicate_field(
5339										"leiCode",
5340									));
5341								}
5342								r#lei_code_property = Some({
5343									struct DeserializeWith(Vec<LeiCodeProperty>);
5344									impl<'de> Deserialize<'de> for DeserializeWith {
5345										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5346										where
5347											D: Deserializer<'de>,
5348										{
5349											Ok(DeserializeWith(serde_with::As::<
5350												serde_with::OneOrMany<serde_with::Same>,
5351											>::deserialize(deserializer)?))
5352										}
5353									}
5354									match map.next_value::<DeserializeWith>() {
5355										Ok(deserialize_with) => deserialize_with.0,
5356										Err(err) => {
5357											return Err(err);
5358										}
5359									}
5360								});
5361							}
5362							Field::Location => {
5363								if r#location_property.is_some() {
5364									return Err(<A::Error as de::Error>::duplicate_field(
5365										"location",
5366									));
5367								}
5368								r#location_property = Some({
5369									struct DeserializeWith(Vec<LocationProperty>);
5370									impl<'de> Deserialize<'de> for DeserializeWith {
5371										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5372										where
5373											D: Deserializer<'de>,
5374										{
5375											Ok(DeserializeWith(serde_with::As::<
5376												serde_with::OneOrMany<serde_with::Same>,
5377											>::deserialize(deserializer)?))
5378										}
5379									}
5380									match map.next_value::<DeserializeWith>() {
5381										Ok(deserialize_with) => deserialize_with.0,
5382										Err(err) => {
5383											return Err(err);
5384										}
5385									}
5386								});
5387							}
5388							Field::Logo => {
5389								if r#logo_property.is_some() {
5390									return Err(<A::Error as de::Error>::duplicate_field("logo"));
5391								}
5392								r#logo_property = Some({
5393									struct DeserializeWith(Vec<LogoProperty>);
5394									impl<'de> Deserialize<'de> for DeserializeWith {
5395										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5396										where
5397											D: Deserializer<'de>,
5398										{
5399											Ok(DeserializeWith(serde_with::As::<
5400												serde_with::OneOrMany<serde_with::Same>,
5401											>::deserialize(deserializer)?))
5402										}
5403									}
5404									match map.next_value::<DeserializeWith>() {
5405										Ok(deserialize_with) => deserialize_with.0,
5406										Err(err) => {
5407											return Err(err);
5408										}
5409									}
5410								});
5411							}
5412							Field::MakesOffer => {
5413								if r#makes_offer_property.is_some() {
5414									return Err(<A::Error as de::Error>::duplicate_field(
5415										"makesOffer",
5416									));
5417								}
5418								r#makes_offer_property = Some({
5419									struct DeserializeWith(Vec<MakesOfferProperty>);
5420									impl<'de> Deserialize<'de> for DeserializeWith {
5421										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5422										where
5423											D: Deserializer<'de>,
5424										{
5425											Ok(DeserializeWith(serde_with::As::<
5426												serde_with::OneOrMany<serde_with::Same>,
5427											>::deserialize(deserializer)?))
5428										}
5429									}
5430									match map.next_value::<DeserializeWith>() {
5431										Ok(deserialize_with) => deserialize_with.0,
5432										Err(err) => {
5433											return Err(err);
5434										}
5435									}
5436								});
5437							}
5438							Field::Member => {
5439								if r#member_property.is_some() {
5440									return Err(<A::Error as de::Error>::duplicate_field("member"));
5441								}
5442								r#member_property = Some({
5443									struct DeserializeWith(Vec<MemberProperty>);
5444									impl<'de> Deserialize<'de> for DeserializeWith {
5445										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5446										where
5447											D: Deserializer<'de>,
5448										{
5449											Ok(DeserializeWith(serde_with::As::<
5450												serde_with::OneOrMany<serde_with::Same>,
5451											>::deserialize(deserializer)?))
5452										}
5453									}
5454									match map.next_value::<DeserializeWith>() {
5455										Ok(deserialize_with) => deserialize_with.0,
5456										Err(err) => {
5457											return Err(err);
5458										}
5459									}
5460								});
5461							}
5462							Field::MemberOf => {
5463								if r#member_of_property.is_some() {
5464									return Err(<A::Error as de::Error>::duplicate_field(
5465										"memberOf",
5466									));
5467								}
5468								r#member_of_property = Some({
5469									struct DeserializeWith(Vec<MemberOfProperty>);
5470									impl<'de> Deserialize<'de> for DeserializeWith {
5471										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5472										where
5473											D: Deserializer<'de>,
5474										{
5475											Ok(DeserializeWith(serde_with::As::<
5476												serde_with::OneOrMany<serde_with::Same>,
5477											>::deserialize(deserializer)?))
5478										}
5479									}
5480									match map.next_value::<DeserializeWith>() {
5481										Ok(deserialize_with) => deserialize_with.0,
5482										Err(err) => {
5483											return Err(err);
5484										}
5485									}
5486								});
5487							}
5488							Field::Members => {
5489								if r#members_property.is_some() {
5490									return Err(<A::Error as de::Error>::duplicate_field(
5491										"members",
5492									));
5493								}
5494								r#members_property = Some({
5495									struct DeserializeWith(Vec<MembersProperty>);
5496									impl<'de> Deserialize<'de> for DeserializeWith {
5497										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5498										where
5499											D: Deserializer<'de>,
5500										{
5501											Ok(DeserializeWith(serde_with::As::<
5502												serde_with::OneOrMany<serde_with::Same>,
5503											>::deserialize(deserializer)?))
5504										}
5505									}
5506									match map.next_value::<DeserializeWith>() {
5507										Ok(deserialize_with) => deserialize_with.0,
5508										Err(err) => {
5509											return Err(err);
5510										}
5511									}
5512								});
5513							}
5514							Field::Naics => {
5515								if r#naics_property.is_some() {
5516									return Err(<A::Error as de::Error>::duplicate_field("naics"));
5517								}
5518								r#naics_property = Some({
5519									struct DeserializeWith(Vec<NaicsProperty>);
5520									impl<'de> Deserialize<'de> for DeserializeWith {
5521										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5522										where
5523											D: Deserializer<'de>,
5524										{
5525											Ok(DeserializeWith(serde_with::As::<
5526												serde_with::OneOrMany<serde_with::Same>,
5527											>::deserialize(deserializer)?))
5528										}
5529									}
5530									match map.next_value::<DeserializeWith>() {
5531										Ok(deserialize_with) => deserialize_with.0,
5532										Err(err) => {
5533											return Err(err);
5534										}
5535									}
5536								});
5537							}
5538							Field::NonprofitStatus => {
5539								if r#nonprofit_status_property.is_some() {
5540									return Err(<A::Error as de::Error>::duplicate_field(
5541										"nonprofitStatus",
5542									));
5543								}
5544								r#nonprofit_status_property = Some({
5545									struct DeserializeWith(Vec<NonprofitStatusProperty>);
5546									impl<'de> Deserialize<'de> for DeserializeWith {
5547										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5548										where
5549											D: Deserializer<'de>,
5550										{
5551											Ok(DeserializeWith(serde_with::As::<
5552												serde_with::OneOrMany<serde_with::Same>,
5553											>::deserialize(deserializer)?))
5554										}
5555									}
5556									match map.next_value::<DeserializeWith>() {
5557										Ok(deserialize_with) => deserialize_with.0,
5558										Err(err) => {
5559											return Err(err);
5560										}
5561									}
5562								});
5563							}
5564							Field::NumberOfEmployees => {
5565								if r#number_of_employees_property.is_some() {
5566									return Err(<A::Error as de::Error>::duplicate_field(
5567										"numberOfEmployees",
5568									));
5569								}
5570								r#number_of_employees_property = Some({
5571									struct DeserializeWith(Vec<NumberOfEmployeesProperty>);
5572									impl<'de> Deserialize<'de> for DeserializeWith {
5573										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5574										where
5575											D: Deserializer<'de>,
5576										{
5577											Ok(DeserializeWith(serde_with::As::<
5578												serde_with::OneOrMany<serde_with::Same>,
5579											>::deserialize(deserializer)?))
5580										}
5581									}
5582									match map.next_value::<DeserializeWith>() {
5583										Ok(deserialize_with) => deserialize_with.0,
5584										Err(err) => {
5585											return Err(err);
5586										}
5587									}
5588								});
5589							}
5590							Field::OwnershipFundingInfo => {
5591								if r#ownership_funding_info_property.is_some() {
5592									return Err(<A::Error as de::Error>::duplicate_field(
5593										"ownershipFundingInfo",
5594									));
5595								}
5596								r#ownership_funding_info_property = Some({
5597									struct DeserializeWith(Vec<OwnershipFundingInfoProperty>);
5598									impl<'de> Deserialize<'de> for DeserializeWith {
5599										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5600										where
5601											D: Deserializer<'de>,
5602										{
5603											Ok(DeserializeWith(serde_with::As::<
5604												serde_with::OneOrMany<serde_with::Same>,
5605											>::deserialize(deserializer)?))
5606										}
5607									}
5608									match map.next_value::<DeserializeWith>() {
5609										Ok(deserialize_with) => deserialize_with.0,
5610										Err(err) => {
5611											return Err(err);
5612										}
5613									}
5614								});
5615							}
5616							Field::Owns => {
5617								if r#owns_property.is_some() {
5618									return Err(<A::Error as de::Error>::duplicate_field("owns"));
5619								}
5620								r#owns_property = Some({
5621									struct DeserializeWith(Vec<OwnsProperty>);
5622									impl<'de> Deserialize<'de> for DeserializeWith {
5623										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5624										where
5625											D: Deserializer<'de>,
5626										{
5627											Ok(DeserializeWith(serde_with::As::<
5628												serde_with::OneOrMany<serde_with::Same>,
5629											>::deserialize(deserializer)?))
5630										}
5631									}
5632									match map.next_value::<DeserializeWith>() {
5633										Ok(deserialize_with) => deserialize_with.0,
5634										Err(err) => {
5635											return Err(err);
5636										}
5637									}
5638								});
5639							}
5640							Field::ParentOrganization => {
5641								if r#parent_organization_property.is_some() {
5642									return Err(<A::Error as de::Error>::duplicate_field(
5643										"parentOrganization",
5644									));
5645								}
5646								r#parent_organization_property = Some({
5647									struct DeserializeWith(Vec<ParentOrganizationProperty>);
5648									impl<'de> Deserialize<'de> for DeserializeWith {
5649										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5650										where
5651											D: Deserializer<'de>,
5652										{
5653											Ok(DeserializeWith(serde_with::As::<
5654												serde_with::OneOrMany<serde_with::Same>,
5655											>::deserialize(deserializer)?))
5656										}
5657									}
5658									match map.next_value::<DeserializeWith>() {
5659										Ok(deserialize_with) => deserialize_with.0,
5660										Err(err) => {
5661											return Err(err);
5662										}
5663									}
5664								});
5665							}
5666							Field::PublishingPrinciples => {
5667								if r#publishing_principles_property.is_some() {
5668									return Err(<A::Error as de::Error>::duplicate_field(
5669										"publishingPrinciples",
5670									));
5671								}
5672								r#publishing_principles_property = Some({
5673									struct DeserializeWith(Vec<PublishingPrinciplesProperty>);
5674									impl<'de> Deserialize<'de> for DeserializeWith {
5675										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5676										where
5677											D: Deserializer<'de>,
5678										{
5679											Ok(DeserializeWith(serde_with::As::<
5680												serde_with::OneOrMany<serde_with::Same>,
5681											>::deserialize(deserializer)?))
5682										}
5683									}
5684									match map.next_value::<DeserializeWith>() {
5685										Ok(deserialize_with) => deserialize_with.0,
5686										Err(err) => {
5687											return Err(err);
5688										}
5689									}
5690								});
5691							}
5692							Field::Review => {
5693								if r#review_property.is_some() {
5694									return Err(<A::Error as de::Error>::duplicate_field("review"));
5695								}
5696								r#review_property = Some({
5697									struct DeserializeWith(Vec<ReviewProperty>);
5698									impl<'de> Deserialize<'de> for DeserializeWith {
5699										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5700										where
5701											D: Deserializer<'de>,
5702										{
5703											Ok(DeserializeWith(serde_with::As::<
5704												serde_with::OneOrMany<serde_with::Same>,
5705											>::deserialize(deserializer)?))
5706										}
5707									}
5708									match map.next_value::<DeserializeWith>() {
5709										Ok(deserialize_with) => deserialize_with.0,
5710										Err(err) => {
5711											return Err(err);
5712										}
5713									}
5714								});
5715							}
5716							Field::Reviews => {
5717								if r#reviews_property.is_some() {
5718									return Err(<A::Error as de::Error>::duplicate_field(
5719										"reviews",
5720									));
5721								}
5722								r#reviews_property = Some({
5723									struct DeserializeWith(Vec<ReviewsProperty>);
5724									impl<'de> Deserialize<'de> for DeserializeWith {
5725										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5726										where
5727											D: Deserializer<'de>,
5728										{
5729											Ok(DeserializeWith(serde_with::As::<
5730												serde_with::OneOrMany<serde_with::Same>,
5731											>::deserialize(deserializer)?))
5732										}
5733									}
5734									match map.next_value::<DeserializeWith>() {
5735										Ok(deserialize_with) => deserialize_with.0,
5736										Err(err) => {
5737											return Err(err);
5738										}
5739									}
5740								});
5741							}
5742							Field::Seeks => {
5743								if r#seeks_property.is_some() {
5744									return Err(<A::Error as de::Error>::duplicate_field("seeks"));
5745								}
5746								r#seeks_property = Some({
5747									struct DeserializeWith(Vec<SeeksProperty>);
5748									impl<'de> Deserialize<'de> for DeserializeWith {
5749										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5750										where
5751											D: Deserializer<'de>,
5752										{
5753											Ok(DeserializeWith(serde_with::As::<
5754												serde_with::OneOrMany<serde_with::Same>,
5755											>::deserialize(deserializer)?))
5756										}
5757									}
5758									match map.next_value::<DeserializeWith>() {
5759										Ok(deserialize_with) => deserialize_with.0,
5760										Err(err) => {
5761											return Err(err);
5762										}
5763									}
5764								});
5765							}
5766							Field::ServiceArea => {
5767								if r#service_area_property.is_some() {
5768									return Err(<A::Error as de::Error>::duplicate_field(
5769										"serviceArea",
5770									));
5771								}
5772								r#service_area_property = Some({
5773									struct DeserializeWith(Vec<ServiceAreaProperty>);
5774									impl<'de> Deserialize<'de> for DeserializeWith {
5775										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5776										where
5777											D: Deserializer<'de>,
5778										{
5779											Ok(DeserializeWith(serde_with::As::<
5780												serde_with::OneOrMany<serde_with::Same>,
5781											>::deserialize(deserializer)?))
5782										}
5783									}
5784									match map.next_value::<DeserializeWith>() {
5785										Ok(deserialize_with) => deserialize_with.0,
5786										Err(err) => {
5787											return Err(err);
5788										}
5789									}
5790								});
5791							}
5792							Field::Slogan => {
5793								if r#slogan_property.is_some() {
5794									return Err(<A::Error as de::Error>::duplicate_field("slogan"));
5795								}
5796								r#slogan_property = Some({
5797									struct DeserializeWith(Vec<SloganProperty>);
5798									impl<'de> Deserialize<'de> for DeserializeWith {
5799										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5800										where
5801											D: Deserializer<'de>,
5802										{
5803											Ok(DeserializeWith(serde_with::As::<
5804												serde_with::OneOrMany<serde_with::Same>,
5805											>::deserialize(deserializer)?))
5806										}
5807									}
5808									match map.next_value::<DeserializeWith>() {
5809										Ok(deserialize_with) => deserialize_with.0,
5810										Err(err) => {
5811											return Err(err);
5812										}
5813									}
5814								});
5815							}
5816							Field::Sponsor => {
5817								if r#sponsor_property.is_some() {
5818									return Err(<A::Error as de::Error>::duplicate_field(
5819										"sponsor",
5820									));
5821								}
5822								r#sponsor_property = Some({
5823									struct DeserializeWith(Vec<SponsorProperty>);
5824									impl<'de> Deserialize<'de> for DeserializeWith {
5825										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5826										where
5827											D: Deserializer<'de>,
5828										{
5829											Ok(DeserializeWith(serde_with::As::<
5830												serde_with::OneOrMany<serde_with::Same>,
5831											>::deserialize(deserializer)?))
5832										}
5833									}
5834									match map.next_value::<DeserializeWith>() {
5835										Ok(deserialize_with) => deserialize_with.0,
5836										Err(err) => {
5837											return Err(err);
5838										}
5839									}
5840								});
5841							}
5842							Field::SubOrganization => {
5843								if r#sub_organization_property.is_some() {
5844									return Err(<A::Error as de::Error>::duplicate_field(
5845										"subOrganization",
5846									));
5847								}
5848								r#sub_organization_property = Some({
5849									struct DeserializeWith(Vec<SubOrganizationProperty>);
5850									impl<'de> Deserialize<'de> for DeserializeWith {
5851										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5852										where
5853											D: Deserializer<'de>,
5854										{
5855											Ok(DeserializeWith(serde_with::As::<
5856												serde_with::OneOrMany<serde_with::Same>,
5857											>::deserialize(deserializer)?))
5858										}
5859									}
5860									match map.next_value::<DeserializeWith>() {
5861										Ok(deserialize_with) => deserialize_with.0,
5862										Err(err) => {
5863											return Err(err);
5864										}
5865									}
5866								});
5867							}
5868							Field::TaxId => {
5869								if r#tax_id_property.is_some() {
5870									return Err(<A::Error as de::Error>::duplicate_field("taxID"));
5871								}
5872								r#tax_id_property = Some({
5873									struct DeserializeWith(Vec<TaxIdProperty>);
5874									impl<'de> Deserialize<'de> for DeserializeWith {
5875										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5876										where
5877											D: Deserializer<'de>,
5878										{
5879											Ok(DeserializeWith(serde_with::As::<
5880												serde_with::OneOrMany<serde_with::Same>,
5881											>::deserialize(deserializer)?))
5882										}
5883									}
5884									match map.next_value::<DeserializeWith>() {
5885										Ok(deserialize_with) => deserialize_with.0,
5886										Err(err) => {
5887											return Err(err);
5888										}
5889									}
5890								});
5891							}
5892							Field::Telephone => {
5893								if r#telephone_property.is_some() {
5894									return Err(<A::Error as de::Error>::duplicate_field(
5895										"telephone",
5896									));
5897								}
5898								r#telephone_property = Some({
5899									struct DeserializeWith(Vec<TelephoneProperty>);
5900									impl<'de> Deserialize<'de> for DeserializeWith {
5901										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5902										where
5903											D: Deserializer<'de>,
5904										{
5905											Ok(DeserializeWith(serde_with::As::<
5906												serde_with::OneOrMany<serde_with::Same>,
5907											>::deserialize(deserializer)?))
5908										}
5909									}
5910									match map.next_value::<DeserializeWith>() {
5911										Ok(deserialize_with) => deserialize_with.0,
5912										Err(err) => {
5913											return Err(err);
5914										}
5915									}
5916								});
5917							}
5918							Field::UnnamedSourcesPolicy => {
5919								if r#unnamed_sources_policy_property.is_some() {
5920									return Err(<A::Error as de::Error>::duplicate_field(
5921										"unnamedSourcesPolicy",
5922									));
5923								}
5924								r#unnamed_sources_policy_property = Some({
5925									struct DeserializeWith(Vec<UnnamedSourcesPolicyProperty>);
5926									impl<'de> Deserialize<'de> for DeserializeWith {
5927										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5928										where
5929											D: Deserializer<'de>,
5930										{
5931											Ok(DeserializeWith(serde_with::As::<
5932												serde_with::OneOrMany<serde_with::Same>,
5933											>::deserialize(deserializer)?))
5934										}
5935									}
5936									match map.next_value::<DeserializeWith>() {
5937										Ok(deserialize_with) => deserialize_with.0,
5938										Err(err) => {
5939											return Err(err);
5940										}
5941									}
5942								});
5943							}
5944							Field::VatId => {
5945								if r#vat_id_property.is_some() {
5946									return Err(<A::Error as de::Error>::duplicate_field("vatID"));
5947								}
5948								r#vat_id_property = Some({
5949									struct DeserializeWith(Vec<VatIdProperty>);
5950									impl<'de> Deserialize<'de> for DeserializeWith {
5951										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5952										where
5953											D: Deserializer<'de>,
5954										{
5955											Ok(DeserializeWith(serde_with::As::<
5956												serde_with::OneOrMany<serde_with::Same>,
5957											>::deserialize(deserializer)?))
5958										}
5959									}
5960									match map.next_value::<DeserializeWith>() {
5961										Ok(deserialize_with) => deserialize_with.0,
5962										Err(err) => {
5963											return Err(err);
5964										}
5965									}
5966								});
5967							}
5968							Field::AdditionalProperty => {
5969								if r#additional_property_property.is_some() {
5970									return Err(<A::Error as de::Error>::duplicate_field(
5971										"additionalProperty",
5972									));
5973								}
5974								r#additional_property_property = Some({
5975									struct DeserializeWith(Vec<AdditionalPropertyProperty>);
5976									impl<'de> Deserialize<'de> for DeserializeWith {
5977										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5978										where
5979											D: Deserializer<'de>,
5980										{
5981											Ok(DeserializeWith(serde_with::As::<
5982												serde_with::OneOrMany<serde_with::Same>,
5983											>::deserialize(deserializer)?))
5984										}
5985									}
5986									match map.next_value::<DeserializeWith>() {
5987										Ok(deserialize_with) => deserialize_with.0,
5988										Err(err) => {
5989											return Err(err);
5990										}
5991									}
5992								});
5993							}
5994							Field::AmenityFeature => {
5995								if r#amenity_feature_property.is_some() {
5996									return Err(<A::Error as de::Error>::duplicate_field(
5997										"amenityFeature",
5998									));
5999								}
6000								r#amenity_feature_property = Some({
6001									struct DeserializeWith(Vec<AmenityFeatureProperty>);
6002									impl<'de> Deserialize<'de> for DeserializeWith {
6003										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6004										where
6005											D: Deserializer<'de>,
6006										{
6007											Ok(DeserializeWith(serde_with::As::<
6008												serde_with::OneOrMany<serde_with::Same>,
6009											>::deserialize(deserializer)?))
6010										}
6011									}
6012									match map.next_value::<DeserializeWith>() {
6013										Ok(deserialize_with) => deserialize_with.0,
6014										Err(err) => {
6015											return Err(err);
6016										}
6017									}
6018								});
6019							}
6020							Field::BranchCode => {
6021								if r#branch_code_property.is_some() {
6022									return Err(<A::Error as de::Error>::duplicate_field(
6023										"branchCode",
6024									));
6025								}
6026								r#branch_code_property = Some({
6027									struct DeserializeWith(Vec<BranchCodeProperty>);
6028									impl<'de> Deserialize<'de> for DeserializeWith {
6029										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6030										where
6031											D: Deserializer<'de>,
6032										{
6033											Ok(DeserializeWith(serde_with::As::<
6034												serde_with::OneOrMany<serde_with::Same>,
6035											>::deserialize(deserializer)?))
6036										}
6037									}
6038									match map.next_value::<DeserializeWith>() {
6039										Ok(deserialize_with) => deserialize_with.0,
6040										Err(err) => {
6041											return Err(err);
6042										}
6043									}
6044								});
6045							}
6046							Field::ContainedIn => {
6047								if r#contained_in_property.is_some() {
6048									return Err(<A::Error as de::Error>::duplicate_field(
6049										"containedIn",
6050									));
6051								}
6052								r#contained_in_property = Some({
6053									struct DeserializeWith(Vec<ContainedInProperty>);
6054									impl<'de> Deserialize<'de> for DeserializeWith {
6055										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6056										where
6057											D: Deserializer<'de>,
6058										{
6059											Ok(DeserializeWith(serde_with::As::<
6060												serde_with::OneOrMany<serde_with::Same>,
6061											>::deserialize(deserializer)?))
6062										}
6063									}
6064									match map.next_value::<DeserializeWith>() {
6065										Ok(deserialize_with) => deserialize_with.0,
6066										Err(err) => {
6067											return Err(err);
6068										}
6069									}
6070								});
6071							}
6072							Field::ContainedInPlace => {
6073								if r#contained_in_place_property.is_some() {
6074									return Err(<A::Error as de::Error>::duplicate_field(
6075										"containedInPlace",
6076									));
6077								}
6078								r#contained_in_place_property = Some({
6079									struct DeserializeWith(Vec<ContainedInPlaceProperty>);
6080									impl<'de> Deserialize<'de> for DeserializeWith {
6081										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6082										where
6083											D: Deserializer<'de>,
6084										{
6085											Ok(DeserializeWith(serde_with::As::<
6086												serde_with::OneOrMany<serde_with::Same>,
6087											>::deserialize(deserializer)?))
6088										}
6089									}
6090									match map.next_value::<DeserializeWith>() {
6091										Ok(deserialize_with) => deserialize_with.0,
6092										Err(err) => {
6093											return Err(err);
6094										}
6095									}
6096								});
6097							}
6098							Field::ContainsPlace => {
6099								if r#contains_place_property.is_some() {
6100									return Err(<A::Error as de::Error>::duplicate_field(
6101										"containsPlace",
6102									));
6103								}
6104								r#contains_place_property = Some({
6105									struct DeserializeWith(Vec<ContainsPlaceProperty>);
6106									impl<'de> Deserialize<'de> for DeserializeWith {
6107										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6108										where
6109											D: Deserializer<'de>,
6110										{
6111											Ok(DeserializeWith(serde_with::As::<
6112												serde_with::OneOrMany<serde_with::Same>,
6113											>::deserialize(deserializer)?))
6114										}
6115									}
6116									match map.next_value::<DeserializeWith>() {
6117										Ok(deserialize_with) => deserialize_with.0,
6118										Err(err) => {
6119											return Err(err);
6120										}
6121									}
6122								});
6123							}
6124							Field::Geo => {
6125								if r#geo_property.is_some() {
6126									return Err(<A::Error as de::Error>::duplicate_field("geo"));
6127								}
6128								r#geo_property = Some({
6129									struct DeserializeWith(Vec<GeoProperty>);
6130									impl<'de> Deserialize<'de> for DeserializeWith {
6131										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6132										where
6133											D: Deserializer<'de>,
6134										{
6135											Ok(DeserializeWith(serde_with::As::<
6136												serde_with::OneOrMany<serde_with::Same>,
6137											>::deserialize(deserializer)?))
6138										}
6139									}
6140									match map.next_value::<DeserializeWith>() {
6141										Ok(deserialize_with) => deserialize_with.0,
6142										Err(err) => {
6143											return Err(err);
6144										}
6145									}
6146								});
6147							}
6148							Field::GeoContains => {
6149								if r#geo_contains_property.is_some() {
6150									return Err(<A::Error as de::Error>::duplicate_field(
6151										"geoContains",
6152									));
6153								}
6154								r#geo_contains_property = Some({
6155									struct DeserializeWith(Vec<GeoContainsProperty>);
6156									impl<'de> Deserialize<'de> for DeserializeWith {
6157										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6158										where
6159											D: Deserializer<'de>,
6160										{
6161											Ok(DeserializeWith(serde_with::As::<
6162												serde_with::OneOrMany<serde_with::Same>,
6163											>::deserialize(deserializer)?))
6164										}
6165									}
6166									match map.next_value::<DeserializeWith>() {
6167										Ok(deserialize_with) => deserialize_with.0,
6168										Err(err) => {
6169											return Err(err);
6170										}
6171									}
6172								});
6173							}
6174							Field::GeoCoveredBy => {
6175								if r#geo_covered_by_property.is_some() {
6176									return Err(<A::Error as de::Error>::duplicate_field(
6177										"geoCoveredBy",
6178									));
6179								}
6180								r#geo_covered_by_property = Some({
6181									struct DeserializeWith(Vec<GeoCoveredByProperty>);
6182									impl<'de> Deserialize<'de> for DeserializeWith {
6183										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6184										where
6185											D: Deserializer<'de>,
6186										{
6187											Ok(DeserializeWith(serde_with::As::<
6188												serde_with::OneOrMany<serde_with::Same>,
6189											>::deserialize(deserializer)?))
6190										}
6191									}
6192									match map.next_value::<DeserializeWith>() {
6193										Ok(deserialize_with) => deserialize_with.0,
6194										Err(err) => {
6195											return Err(err);
6196										}
6197									}
6198								});
6199							}
6200							Field::GeoCovers => {
6201								if r#geo_covers_property.is_some() {
6202									return Err(<A::Error as de::Error>::duplicate_field(
6203										"geoCovers",
6204									));
6205								}
6206								r#geo_covers_property = Some({
6207									struct DeserializeWith(Vec<GeoCoversProperty>);
6208									impl<'de> Deserialize<'de> for DeserializeWith {
6209										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6210										where
6211											D: Deserializer<'de>,
6212										{
6213											Ok(DeserializeWith(serde_with::As::<
6214												serde_with::OneOrMany<serde_with::Same>,
6215											>::deserialize(deserializer)?))
6216										}
6217									}
6218									match map.next_value::<DeserializeWith>() {
6219										Ok(deserialize_with) => deserialize_with.0,
6220										Err(err) => {
6221											return Err(err);
6222										}
6223									}
6224								});
6225							}
6226							Field::GeoCrosses => {
6227								if r#geo_crosses_property.is_some() {
6228									return Err(<A::Error as de::Error>::duplicate_field(
6229										"geoCrosses",
6230									));
6231								}
6232								r#geo_crosses_property = Some({
6233									struct DeserializeWith(Vec<GeoCrossesProperty>);
6234									impl<'de> Deserialize<'de> for DeserializeWith {
6235										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6236										where
6237											D: Deserializer<'de>,
6238										{
6239											Ok(DeserializeWith(serde_with::As::<
6240												serde_with::OneOrMany<serde_with::Same>,
6241											>::deserialize(deserializer)?))
6242										}
6243									}
6244									match map.next_value::<DeserializeWith>() {
6245										Ok(deserialize_with) => deserialize_with.0,
6246										Err(err) => {
6247											return Err(err);
6248										}
6249									}
6250								});
6251							}
6252							Field::GeoDisjoint => {
6253								if r#geo_disjoint_property.is_some() {
6254									return Err(<A::Error as de::Error>::duplicate_field(
6255										"geoDisjoint",
6256									));
6257								}
6258								r#geo_disjoint_property = Some({
6259									struct DeserializeWith(Vec<GeoDisjointProperty>);
6260									impl<'de> Deserialize<'de> for DeserializeWith {
6261										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6262										where
6263											D: Deserializer<'de>,
6264										{
6265											Ok(DeserializeWith(serde_with::As::<
6266												serde_with::OneOrMany<serde_with::Same>,
6267											>::deserialize(deserializer)?))
6268										}
6269									}
6270									match map.next_value::<DeserializeWith>() {
6271										Ok(deserialize_with) => deserialize_with.0,
6272										Err(err) => {
6273											return Err(err);
6274										}
6275									}
6276								});
6277							}
6278							Field::GeoEquals => {
6279								if r#geo_equals_property.is_some() {
6280									return Err(<A::Error as de::Error>::duplicate_field(
6281										"geoEquals",
6282									));
6283								}
6284								r#geo_equals_property = Some({
6285									struct DeserializeWith(Vec<GeoEqualsProperty>);
6286									impl<'de> Deserialize<'de> for DeserializeWith {
6287										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6288										where
6289											D: Deserializer<'de>,
6290										{
6291											Ok(DeserializeWith(serde_with::As::<
6292												serde_with::OneOrMany<serde_with::Same>,
6293											>::deserialize(deserializer)?))
6294										}
6295									}
6296									match map.next_value::<DeserializeWith>() {
6297										Ok(deserialize_with) => deserialize_with.0,
6298										Err(err) => {
6299											return Err(err);
6300										}
6301									}
6302								});
6303							}
6304							Field::GeoIntersects => {
6305								if r#geo_intersects_property.is_some() {
6306									return Err(<A::Error as de::Error>::duplicate_field(
6307										"geoIntersects",
6308									));
6309								}
6310								r#geo_intersects_property = Some({
6311									struct DeserializeWith(Vec<GeoIntersectsProperty>);
6312									impl<'de> Deserialize<'de> for DeserializeWith {
6313										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6314										where
6315											D: Deserializer<'de>,
6316										{
6317											Ok(DeserializeWith(serde_with::As::<
6318												serde_with::OneOrMany<serde_with::Same>,
6319											>::deserialize(deserializer)?))
6320										}
6321									}
6322									match map.next_value::<DeserializeWith>() {
6323										Ok(deserialize_with) => deserialize_with.0,
6324										Err(err) => {
6325											return Err(err);
6326										}
6327									}
6328								});
6329							}
6330							Field::GeoOverlaps => {
6331								if r#geo_overlaps_property.is_some() {
6332									return Err(<A::Error as de::Error>::duplicate_field(
6333										"geoOverlaps",
6334									));
6335								}
6336								r#geo_overlaps_property = Some({
6337									struct DeserializeWith(Vec<GeoOverlapsProperty>);
6338									impl<'de> Deserialize<'de> for DeserializeWith {
6339										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6340										where
6341											D: Deserializer<'de>,
6342										{
6343											Ok(DeserializeWith(serde_with::As::<
6344												serde_with::OneOrMany<serde_with::Same>,
6345											>::deserialize(deserializer)?))
6346										}
6347									}
6348									match map.next_value::<DeserializeWith>() {
6349										Ok(deserialize_with) => deserialize_with.0,
6350										Err(err) => {
6351											return Err(err);
6352										}
6353									}
6354								});
6355							}
6356							Field::GeoTouches => {
6357								if r#geo_touches_property.is_some() {
6358									return Err(<A::Error as de::Error>::duplicate_field(
6359										"geoTouches",
6360									));
6361								}
6362								r#geo_touches_property = Some({
6363									struct DeserializeWith(Vec<GeoTouchesProperty>);
6364									impl<'de> Deserialize<'de> for DeserializeWith {
6365										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6366										where
6367											D: Deserializer<'de>,
6368										{
6369											Ok(DeserializeWith(serde_with::As::<
6370												serde_with::OneOrMany<serde_with::Same>,
6371											>::deserialize(deserializer)?))
6372										}
6373									}
6374									match map.next_value::<DeserializeWith>() {
6375										Ok(deserialize_with) => deserialize_with.0,
6376										Err(err) => {
6377											return Err(err);
6378										}
6379									}
6380								});
6381							}
6382							Field::GeoWithin => {
6383								if r#geo_within_property.is_some() {
6384									return Err(<A::Error as de::Error>::duplicate_field(
6385										"geoWithin",
6386									));
6387								}
6388								r#geo_within_property = Some({
6389									struct DeserializeWith(Vec<GeoWithinProperty>);
6390									impl<'de> Deserialize<'de> for DeserializeWith {
6391										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6392										where
6393											D: Deserializer<'de>,
6394										{
6395											Ok(DeserializeWith(serde_with::As::<
6396												serde_with::OneOrMany<serde_with::Same>,
6397											>::deserialize(deserializer)?))
6398										}
6399									}
6400									match map.next_value::<DeserializeWith>() {
6401										Ok(deserialize_with) => deserialize_with.0,
6402										Err(err) => {
6403											return Err(err);
6404										}
6405									}
6406								});
6407							}
6408							Field::HasDriveThroughService => {
6409								if r#has_drive_through_service_property.is_some() {
6410									return Err(<A::Error as de::Error>::duplicate_field(
6411										"hasDriveThroughService",
6412									));
6413								}
6414								r#has_drive_through_service_property = Some({
6415									struct DeserializeWith(Vec<HasDriveThroughServiceProperty>);
6416									impl<'de> Deserialize<'de> for DeserializeWith {
6417										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6418										where
6419											D: Deserializer<'de>,
6420										{
6421											Ok(DeserializeWith(serde_with::As::<
6422												serde_with::OneOrMany<serde_with::Same>,
6423											>::deserialize(deserializer)?))
6424										}
6425									}
6426									match map.next_value::<DeserializeWith>() {
6427										Ok(deserialize_with) => deserialize_with.0,
6428										Err(err) => {
6429											return Err(err);
6430										}
6431									}
6432								});
6433							}
6434							Field::HasMap => {
6435								if r#has_map_property.is_some() {
6436									return Err(<A::Error as de::Error>::duplicate_field("hasMap"));
6437								}
6438								r#has_map_property = Some({
6439									struct DeserializeWith(Vec<HasMapProperty>);
6440									impl<'de> Deserialize<'de> for DeserializeWith {
6441										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6442										where
6443											D: Deserializer<'de>,
6444										{
6445											Ok(DeserializeWith(serde_with::As::<
6446												serde_with::OneOrMany<serde_with::Same>,
6447											>::deserialize(deserializer)?))
6448										}
6449									}
6450									match map.next_value::<DeserializeWith>() {
6451										Ok(deserialize_with) => deserialize_with.0,
6452										Err(err) => {
6453											return Err(err);
6454										}
6455									}
6456								});
6457							}
6458							Field::IsAccessibleForFree => {
6459								if r#is_accessible_for_free_property.is_some() {
6460									return Err(<A::Error as de::Error>::duplicate_field(
6461										"isAccessibleForFree",
6462									));
6463								}
6464								r#is_accessible_for_free_property = Some({
6465									struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
6466									impl<'de> Deserialize<'de> for DeserializeWith {
6467										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6468										where
6469											D: Deserializer<'de>,
6470										{
6471											Ok(DeserializeWith(serde_with::As::<
6472												serde_with::OneOrMany<serde_with::Same>,
6473											>::deserialize(deserializer)?))
6474										}
6475									}
6476									match map.next_value::<DeserializeWith>() {
6477										Ok(deserialize_with) => deserialize_with.0,
6478										Err(err) => {
6479											return Err(err);
6480										}
6481									}
6482								});
6483							}
6484							Field::Latitude => {
6485								if r#latitude_property.is_some() {
6486									return Err(<A::Error as de::Error>::duplicate_field(
6487										"latitude",
6488									));
6489								}
6490								r#latitude_property = Some({
6491									struct DeserializeWith(Vec<LatitudeProperty>);
6492									impl<'de> Deserialize<'de> for DeserializeWith {
6493										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6494										where
6495											D: Deserializer<'de>,
6496										{
6497											Ok(DeserializeWith(serde_with::As::<
6498												serde_with::OneOrMany<serde_with::Same>,
6499											>::deserialize(deserializer)?))
6500										}
6501									}
6502									match map.next_value::<DeserializeWith>() {
6503										Ok(deserialize_with) => deserialize_with.0,
6504										Err(err) => {
6505											return Err(err);
6506										}
6507									}
6508								});
6509							}
6510							Field::Longitude => {
6511								if r#longitude_property.is_some() {
6512									return Err(<A::Error as de::Error>::duplicate_field(
6513										"longitude",
6514									));
6515								}
6516								r#longitude_property = Some({
6517									struct DeserializeWith(Vec<LongitudeProperty>);
6518									impl<'de> Deserialize<'de> for DeserializeWith {
6519										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6520										where
6521											D: Deserializer<'de>,
6522										{
6523											Ok(DeserializeWith(serde_with::As::<
6524												serde_with::OneOrMany<serde_with::Same>,
6525											>::deserialize(deserializer)?))
6526										}
6527									}
6528									match map.next_value::<DeserializeWith>() {
6529										Ok(deserialize_with) => deserialize_with.0,
6530										Err(err) => {
6531											return Err(err);
6532										}
6533									}
6534								});
6535							}
6536							Field::Map => {
6537								if r#map_property.is_some() {
6538									return Err(<A::Error as de::Error>::duplicate_field("map"));
6539								}
6540								r#map_property = Some({
6541									struct DeserializeWith(Vec<MapProperty>);
6542									impl<'de> Deserialize<'de> for DeserializeWith {
6543										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6544										where
6545											D: Deserializer<'de>,
6546										{
6547											Ok(DeserializeWith(serde_with::As::<
6548												serde_with::OneOrMany<serde_with::Same>,
6549											>::deserialize(deserializer)?))
6550										}
6551									}
6552									match map.next_value::<DeserializeWith>() {
6553										Ok(deserialize_with) => deserialize_with.0,
6554										Err(err) => {
6555											return Err(err);
6556										}
6557									}
6558								});
6559							}
6560							Field::Maps => {
6561								if r#maps_property.is_some() {
6562									return Err(<A::Error as de::Error>::duplicate_field("maps"));
6563								}
6564								r#maps_property = Some({
6565									struct DeserializeWith(Vec<MapsProperty>);
6566									impl<'de> Deserialize<'de> for DeserializeWith {
6567										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6568										where
6569											D: Deserializer<'de>,
6570										{
6571											Ok(DeserializeWith(serde_with::As::<
6572												serde_with::OneOrMany<serde_with::Same>,
6573											>::deserialize(deserializer)?))
6574										}
6575									}
6576									match map.next_value::<DeserializeWith>() {
6577										Ok(deserialize_with) => deserialize_with.0,
6578										Err(err) => {
6579											return Err(err);
6580										}
6581									}
6582								});
6583							}
6584							Field::MaximumAttendeeCapacity => {
6585								if r#maximum_attendee_capacity_property.is_some() {
6586									return Err(<A::Error as de::Error>::duplicate_field(
6587										"maximumAttendeeCapacity",
6588									));
6589								}
6590								r#maximum_attendee_capacity_property = Some({
6591									struct DeserializeWith(Vec<MaximumAttendeeCapacityProperty>);
6592									impl<'de> Deserialize<'de> for DeserializeWith {
6593										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6594										where
6595											D: Deserializer<'de>,
6596										{
6597											Ok(DeserializeWith(serde_with::As::<
6598												serde_with::OneOrMany<serde_with::Same>,
6599											>::deserialize(deserializer)?))
6600										}
6601									}
6602									match map.next_value::<DeserializeWith>() {
6603										Ok(deserialize_with) => deserialize_with.0,
6604										Err(err) => {
6605											return Err(err);
6606										}
6607									}
6608								});
6609							}
6610							Field::OpeningHoursSpecification => {
6611								if r#opening_hours_specification_property.is_some() {
6612									return Err(<A::Error as de::Error>::duplicate_field(
6613										"openingHoursSpecification",
6614									));
6615								}
6616								r#opening_hours_specification_property = Some({
6617									struct DeserializeWith(Vec<OpeningHoursSpecificationProperty>);
6618									impl<'de> Deserialize<'de> for DeserializeWith {
6619										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6620										where
6621											D: Deserializer<'de>,
6622										{
6623											Ok(DeserializeWith(serde_with::As::<
6624												serde_with::OneOrMany<serde_with::Same>,
6625											>::deserialize(deserializer)?))
6626										}
6627									}
6628									match map.next_value::<DeserializeWith>() {
6629										Ok(deserialize_with) => deserialize_with.0,
6630										Err(err) => {
6631											return Err(err);
6632										}
6633									}
6634								});
6635							}
6636							Field::Photo => {
6637								if r#photo_property.is_some() {
6638									return Err(<A::Error as de::Error>::duplicate_field("photo"));
6639								}
6640								r#photo_property = Some({
6641									struct DeserializeWith(Vec<PhotoProperty>);
6642									impl<'de> Deserialize<'de> for DeserializeWith {
6643										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6644										where
6645											D: Deserializer<'de>,
6646										{
6647											Ok(DeserializeWith(serde_with::As::<
6648												serde_with::OneOrMany<serde_with::Same>,
6649											>::deserialize(deserializer)?))
6650										}
6651									}
6652									match map.next_value::<DeserializeWith>() {
6653										Ok(deserialize_with) => deserialize_with.0,
6654										Err(err) => {
6655											return Err(err);
6656										}
6657									}
6658								});
6659							}
6660							Field::Photos => {
6661								if r#photos_property.is_some() {
6662									return Err(<A::Error as de::Error>::duplicate_field("photos"));
6663								}
6664								r#photos_property = Some({
6665									struct DeserializeWith(Vec<PhotosProperty>);
6666									impl<'de> Deserialize<'de> for DeserializeWith {
6667										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6668										where
6669											D: Deserializer<'de>,
6670										{
6671											Ok(DeserializeWith(serde_with::As::<
6672												serde_with::OneOrMany<serde_with::Same>,
6673											>::deserialize(deserializer)?))
6674										}
6675									}
6676									match map.next_value::<DeserializeWith>() {
6677										Ok(deserialize_with) => deserialize_with.0,
6678										Err(err) => {
6679											return Err(err);
6680										}
6681									}
6682								});
6683							}
6684							Field::PublicAccess => {
6685								if r#public_access_property.is_some() {
6686									return Err(<A::Error as de::Error>::duplicate_field(
6687										"publicAccess",
6688									));
6689								}
6690								r#public_access_property = Some({
6691									struct DeserializeWith(Vec<PublicAccessProperty>);
6692									impl<'de> Deserialize<'de> for DeserializeWith {
6693										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6694										where
6695											D: Deserializer<'de>,
6696										{
6697											Ok(DeserializeWith(serde_with::As::<
6698												serde_with::OneOrMany<serde_with::Same>,
6699											>::deserialize(deserializer)?))
6700										}
6701									}
6702									match map.next_value::<DeserializeWith>() {
6703										Ok(deserialize_with) => deserialize_with.0,
6704										Err(err) => {
6705											return Err(err);
6706										}
6707									}
6708								});
6709							}
6710							Field::SmokingAllowed => {
6711								if r#smoking_allowed_property.is_some() {
6712									return Err(<A::Error as de::Error>::duplicate_field(
6713										"smokingAllowed",
6714									));
6715								}
6716								r#smoking_allowed_property = Some({
6717									struct DeserializeWith(Vec<SmokingAllowedProperty>);
6718									impl<'de> Deserialize<'de> for DeserializeWith {
6719										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6720										where
6721											D: Deserializer<'de>,
6722										{
6723											Ok(DeserializeWith(serde_with::As::<
6724												serde_with::OneOrMany<serde_with::Same>,
6725											>::deserialize(deserializer)?))
6726										}
6727									}
6728									match map.next_value::<DeserializeWith>() {
6729										Ok(deserialize_with) => deserialize_with.0,
6730										Err(err) => {
6731											return Err(err);
6732										}
6733									}
6734								});
6735							}
6736							Field::SpecialOpeningHoursSpecification => {
6737								if r#special_opening_hours_specification_property.is_some() {
6738									return Err(<A::Error as de::Error>::duplicate_field(
6739										"specialOpeningHoursSpecification",
6740									));
6741								}
6742								r#special_opening_hours_specification_property = Some({
6743									struct DeserializeWith(
6744										Vec<SpecialOpeningHoursSpecificationProperty>,
6745									);
6746									impl<'de> Deserialize<'de> for DeserializeWith {
6747										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6748										where
6749											D: Deserializer<'de>,
6750										{
6751											Ok(DeserializeWith(serde_with::As::<
6752												serde_with::OneOrMany<serde_with::Same>,
6753											>::deserialize(deserializer)?))
6754										}
6755									}
6756									match map.next_value::<DeserializeWith>() {
6757										Ok(deserialize_with) => deserialize_with.0,
6758										Err(err) => {
6759											return Err(err);
6760										}
6761									}
6762								});
6763							}
6764							Field::TourBookingPage => {
6765								if r#tour_booking_page_property.is_some() {
6766									return Err(<A::Error as de::Error>::duplicate_field(
6767										"tourBookingPage",
6768									));
6769								}
6770								r#tour_booking_page_property = Some({
6771									struct DeserializeWith(Vec<TourBookingPageProperty>);
6772									impl<'de> Deserialize<'de> for DeserializeWith {
6773										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6774										where
6775											D: Deserializer<'de>,
6776										{
6777											Ok(DeserializeWith(serde_with::As::<
6778												serde_with::OneOrMany<serde_with::Same>,
6779											>::deserialize(deserializer)?))
6780										}
6781									}
6782									match map.next_value::<DeserializeWith>() {
6783										Ok(deserialize_with) => deserialize_with.0,
6784										Err(err) => {
6785											return Err(err);
6786										}
6787									}
6788								});
6789							}
6790							Field::AdditionalType => {
6791								if r#additional_type_property.is_some() {
6792									return Err(<A::Error as de::Error>::duplicate_field(
6793										"additionalType",
6794									));
6795								}
6796								r#additional_type_property = Some({
6797									struct DeserializeWith(Vec<AdditionalTypeProperty>);
6798									impl<'de> Deserialize<'de> for DeserializeWith {
6799										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6800										where
6801											D: Deserializer<'de>,
6802										{
6803											Ok(DeserializeWith(serde_with::As::<
6804												serde_with::OneOrMany<serde_with::Same>,
6805											>::deserialize(deserializer)?))
6806										}
6807									}
6808									match map.next_value::<DeserializeWith>() {
6809										Ok(deserialize_with) => deserialize_with.0,
6810										Err(err) => {
6811											return Err(err);
6812										}
6813									}
6814								});
6815							}
6816							Field::AlternateName => {
6817								if r#alternate_name_property.is_some() {
6818									return Err(<A::Error as de::Error>::duplicate_field(
6819										"alternateName",
6820									));
6821								}
6822								r#alternate_name_property = Some({
6823									struct DeserializeWith(Vec<AlternateNameProperty>);
6824									impl<'de> Deserialize<'de> for DeserializeWith {
6825										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6826										where
6827											D: Deserializer<'de>,
6828										{
6829											Ok(DeserializeWith(serde_with::As::<
6830												serde_with::OneOrMany<serde_with::Same>,
6831											>::deserialize(deserializer)?))
6832										}
6833									}
6834									match map.next_value::<DeserializeWith>() {
6835										Ok(deserialize_with) => deserialize_with.0,
6836										Err(err) => {
6837											return Err(err);
6838										}
6839									}
6840								});
6841							}
6842							Field::Description => {
6843								if r#description_property.is_some() {
6844									return Err(<A::Error as de::Error>::duplicate_field(
6845										"description",
6846									));
6847								}
6848								r#description_property = Some({
6849									struct DeserializeWith(Vec<DescriptionProperty>);
6850									impl<'de> Deserialize<'de> for DeserializeWith {
6851										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6852										where
6853											D: Deserializer<'de>,
6854										{
6855											Ok(DeserializeWith(serde_with::As::<
6856												serde_with::OneOrMany<serde_with::Same>,
6857											>::deserialize(deserializer)?))
6858										}
6859									}
6860									match map.next_value::<DeserializeWith>() {
6861										Ok(deserialize_with) => deserialize_with.0,
6862										Err(err) => {
6863											return Err(err);
6864										}
6865									}
6866								});
6867							}
6868							Field::DisambiguatingDescription => {
6869								if r#disambiguating_description_property.is_some() {
6870									return Err(<A::Error as de::Error>::duplicate_field(
6871										"disambiguatingDescription",
6872									));
6873								}
6874								r#disambiguating_description_property = Some({
6875									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
6876									impl<'de> Deserialize<'de> for DeserializeWith {
6877										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6878										where
6879											D: Deserializer<'de>,
6880										{
6881											Ok(DeserializeWith(serde_with::As::<
6882												serde_with::OneOrMany<serde_with::Same>,
6883											>::deserialize(deserializer)?))
6884										}
6885									}
6886									match map.next_value::<DeserializeWith>() {
6887										Ok(deserialize_with) => deserialize_with.0,
6888										Err(err) => {
6889											return Err(err);
6890										}
6891									}
6892								});
6893							}
6894							Field::Identifier => {
6895								if r#identifier_property.is_some() {
6896									return Err(<A::Error as de::Error>::duplicate_field(
6897										"identifier",
6898									));
6899								}
6900								r#identifier_property = Some({
6901									struct DeserializeWith(Vec<IdentifierProperty>);
6902									impl<'de> Deserialize<'de> for DeserializeWith {
6903										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6904										where
6905											D: Deserializer<'de>,
6906										{
6907											Ok(DeserializeWith(serde_with::As::<
6908												serde_with::OneOrMany<serde_with::Same>,
6909											>::deserialize(deserializer)?))
6910										}
6911									}
6912									match map.next_value::<DeserializeWith>() {
6913										Ok(deserialize_with) => deserialize_with.0,
6914										Err(err) => {
6915											return Err(err);
6916										}
6917									}
6918								});
6919							}
6920							Field::Image => {
6921								if r#image_property.is_some() {
6922									return Err(<A::Error as de::Error>::duplicate_field("image"));
6923								}
6924								r#image_property = Some({
6925									struct DeserializeWith(Vec<ImageProperty>);
6926									impl<'de> Deserialize<'de> for DeserializeWith {
6927										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6928										where
6929											D: Deserializer<'de>,
6930										{
6931											Ok(DeserializeWith(serde_with::As::<
6932												serde_with::OneOrMany<serde_with::Same>,
6933											>::deserialize(deserializer)?))
6934										}
6935									}
6936									match map.next_value::<DeserializeWith>() {
6937										Ok(deserialize_with) => deserialize_with.0,
6938										Err(err) => {
6939											return Err(err);
6940										}
6941									}
6942								});
6943							}
6944							Field::MainEntityOfPage => {
6945								if r#main_entity_of_page_property.is_some() {
6946									return Err(<A::Error as de::Error>::duplicate_field(
6947										"mainEntityOfPage",
6948									));
6949								}
6950								r#main_entity_of_page_property = Some({
6951									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
6952									impl<'de> Deserialize<'de> for DeserializeWith {
6953										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6954										where
6955											D: Deserializer<'de>,
6956										{
6957											Ok(DeserializeWith(serde_with::As::<
6958												serde_with::OneOrMany<serde_with::Same>,
6959											>::deserialize(deserializer)?))
6960										}
6961									}
6962									match map.next_value::<DeserializeWith>() {
6963										Ok(deserialize_with) => deserialize_with.0,
6964										Err(err) => {
6965											return Err(err);
6966										}
6967									}
6968								});
6969							}
6970							Field::Name => {
6971								if r#name_property.is_some() {
6972									return Err(<A::Error as de::Error>::duplicate_field("name"));
6973								}
6974								r#name_property = Some({
6975									struct DeserializeWith(Vec<NameProperty>);
6976									impl<'de> Deserialize<'de> for DeserializeWith {
6977										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6978										where
6979											D: Deserializer<'de>,
6980										{
6981											Ok(DeserializeWith(serde_with::As::<
6982												serde_with::OneOrMany<serde_with::Same>,
6983											>::deserialize(deserializer)?))
6984										}
6985									}
6986									match map.next_value::<DeserializeWith>() {
6987										Ok(deserialize_with) => deserialize_with.0,
6988										Err(err) => {
6989											return Err(err);
6990										}
6991									}
6992								});
6993							}
6994							Field::PotentialAction => {
6995								if r#potential_action_property.is_some() {
6996									return Err(<A::Error as de::Error>::duplicate_field(
6997										"potentialAction",
6998									));
6999								}
7000								r#potential_action_property = Some({
7001									struct DeserializeWith(Vec<PotentialActionProperty>);
7002									impl<'de> Deserialize<'de> for DeserializeWith {
7003										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7004										where
7005											D: Deserializer<'de>,
7006										{
7007											Ok(DeserializeWith(serde_with::As::<
7008												serde_with::OneOrMany<serde_with::Same>,
7009											>::deserialize(deserializer)?))
7010										}
7011									}
7012									match map.next_value::<DeserializeWith>() {
7013										Ok(deserialize_with) => deserialize_with.0,
7014										Err(err) => {
7015											return Err(err);
7016										}
7017									}
7018								});
7019							}
7020							Field::SameAs => {
7021								if r#same_as_property.is_some() {
7022									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
7023								}
7024								r#same_as_property = Some({
7025									struct DeserializeWith(Vec<SameAsProperty>);
7026									impl<'de> Deserialize<'de> for DeserializeWith {
7027										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7028										where
7029											D: Deserializer<'de>,
7030										{
7031											Ok(DeserializeWith(serde_with::As::<
7032												serde_with::OneOrMany<serde_with::Same>,
7033											>::deserialize(deserializer)?))
7034										}
7035									}
7036									match map.next_value::<DeserializeWith>() {
7037										Ok(deserialize_with) => deserialize_with.0,
7038										Err(err) => {
7039											return Err(err);
7040										}
7041									}
7042								});
7043							}
7044							Field::SubjectOf => {
7045								if r#subject_of_property.is_some() {
7046									return Err(<A::Error as de::Error>::duplicate_field(
7047										"subjectOf",
7048									));
7049								}
7050								r#subject_of_property = Some({
7051									struct DeserializeWith(Vec<SubjectOfProperty>);
7052									impl<'de> Deserialize<'de> for DeserializeWith {
7053										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7054										where
7055											D: Deserializer<'de>,
7056										{
7057											Ok(DeserializeWith(serde_with::As::<
7058												serde_with::OneOrMany<serde_with::Same>,
7059											>::deserialize(deserializer)?))
7060										}
7061									}
7062									match map.next_value::<DeserializeWith>() {
7063										Ok(deserialize_with) => deserialize_with.0,
7064										Err(err) => {
7065											return Err(err);
7066										}
7067									}
7068								});
7069							}
7070							Field::Url => {
7071								if r#url_property.is_some() {
7072									return Err(<A::Error as de::Error>::duplicate_field("url"));
7073								}
7074								r#url_property = Some({
7075									struct DeserializeWith(Vec<UrlProperty>);
7076									impl<'de> Deserialize<'de> for DeserializeWith {
7077										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7078										where
7079											D: Deserializer<'de>,
7080										{
7081											Ok(DeserializeWith(serde_with::As::<
7082												serde_with::OneOrMany<serde_with::Same>,
7083											>::deserialize(deserializer)?))
7084										}
7085									}
7086									match map.next_value::<DeserializeWith>() {
7087										Ok(deserialize_with) => deserialize_with.0,
7088										Err(err) => {
7089											return Err(err);
7090										}
7091									}
7092								});
7093							}
7094							Field::Ignore => {
7095								let _ = map.next_value::<de::IgnoredAny>()?;
7096							}
7097						}
7098					}
7099					Ok(IceCreamShop {
7100						r#accepts_reservations: r#accepts_reservations_property.unwrap_or_default(),
7101						r#has_menu: r#has_menu_property.unwrap_or_default(),
7102						r#menu: r#menu_property.unwrap_or_default(),
7103						r#serves_cuisine: r#serves_cuisine_property.unwrap_or_default(),
7104						r#star_rating: r#star_rating_property.unwrap_or_default(),
7105						r#branch_of: r#branch_of_property.unwrap_or_default(),
7106						r#currencies_accepted: r#currencies_accepted_property.unwrap_or_default(),
7107						r#opening_hours: r#opening_hours_property.unwrap_or_default(),
7108						r#payment_accepted: r#payment_accepted_property.unwrap_or_default(),
7109						r#price_range: r#price_range_property.unwrap_or_default(),
7110						r#actionable_feedback_policy: r#actionable_feedback_policy_property
7111							.unwrap_or_default(),
7112						r#address: r#address_property.unwrap_or_default(),
7113						r#agent_interaction_statistic: r#agent_interaction_statistic_property
7114							.unwrap_or_default(),
7115						r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
7116						r#alumni: r#alumni_property.unwrap_or_default(),
7117						r#area_served: r#area_served_property.unwrap_or_default(),
7118						r#award: r#award_property.unwrap_or_default(),
7119						r#awards: r#awards_property.unwrap_or_default(),
7120						r#brand: r#brand_property.unwrap_or_default(),
7121						r#contact_point: r#contact_point_property.unwrap_or_default(),
7122						r#contact_points: r#contact_points_property.unwrap_or_default(),
7123						r#corrections_policy: r#corrections_policy_property.unwrap_or_default(),
7124						r#department: r#department_property.unwrap_or_default(),
7125						r#dissolution_date: r#dissolution_date_property.unwrap_or_default(),
7126						r#diversity_policy: r#diversity_policy_property.unwrap_or_default(),
7127						r#diversity_staffing_report: r#diversity_staffing_report_property
7128							.unwrap_or_default(),
7129						r#duns: r#duns_property.unwrap_or_default(),
7130						r#email: r#email_property.unwrap_or_default(),
7131						r#employee: r#employee_property.unwrap_or_default(),
7132						r#employees: r#employees_property.unwrap_or_default(),
7133						r#ethics_policy: r#ethics_policy_property.unwrap_or_default(),
7134						r#event: r#event_property.unwrap_or_default(),
7135						r#events: r#events_property.unwrap_or_default(),
7136						r#fax_number: r#fax_number_property.unwrap_or_default(),
7137						r#founder: r#founder_property.unwrap_or_default(),
7138						r#founders: r#founders_property.unwrap_or_default(),
7139						r#founding_date: r#founding_date_property.unwrap_or_default(),
7140						r#founding_location: r#founding_location_property.unwrap_or_default(),
7141						r#funder: r#funder_property.unwrap_or_default(),
7142						r#funding: r#funding_property.unwrap_or_default(),
7143						r#global_location_number: r#global_location_number_property
7144							.unwrap_or_default(),
7145						r#has_credential: r#has_credential_property.unwrap_or_default(),
7146						r#has_merchant_return_policy: r#has_merchant_return_policy_property
7147							.unwrap_or_default(),
7148						r#has_offer_catalog: r#has_offer_catalog_property.unwrap_or_default(),
7149						r#has_pos: r#has_pos_property.unwrap_or_default(),
7150						r#has_product_return_policy: r#has_product_return_policy_property
7151							.unwrap_or_default(),
7152						r#interaction_statistic: r#interaction_statistic_property
7153							.unwrap_or_default(),
7154						r#isic_v_4: r#isic_v_4_property.unwrap_or_default(),
7155						r#iso_6523_code: r#iso_6523_code_property.unwrap_or_default(),
7156						r#keywords: r#keywords_property.unwrap_or_default(),
7157						r#knows_about: r#knows_about_property.unwrap_or_default(),
7158						r#knows_language: r#knows_language_property.unwrap_or_default(),
7159						r#legal_name: r#legal_name_property.unwrap_or_default(),
7160						r#lei_code: r#lei_code_property.unwrap_or_default(),
7161						r#location: r#location_property.unwrap_or_default(),
7162						r#logo: r#logo_property.unwrap_or_default(),
7163						r#makes_offer: r#makes_offer_property.unwrap_or_default(),
7164						r#member: r#member_property.unwrap_or_default(),
7165						r#member_of: r#member_of_property.unwrap_or_default(),
7166						r#members: r#members_property.unwrap_or_default(),
7167						r#naics: r#naics_property.unwrap_or_default(),
7168						r#nonprofit_status: r#nonprofit_status_property.unwrap_or_default(),
7169						r#number_of_employees: r#number_of_employees_property.unwrap_or_default(),
7170						r#ownership_funding_info: r#ownership_funding_info_property
7171							.unwrap_or_default(),
7172						r#owns: r#owns_property.unwrap_or_default(),
7173						r#parent_organization: r#parent_organization_property.unwrap_or_default(),
7174						r#publishing_principles: r#publishing_principles_property
7175							.unwrap_or_default(),
7176						r#review: r#review_property.unwrap_or_default(),
7177						r#reviews: r#reviews_property.unwrap_or_default(),
7178						r#seeks: r#seeks_property.unwrap_or_default(),
7179						r#service_area: r#service_area_property.unwrap_or_default(),
7180						r#slogan: r#slogan_property.unwrap_or_default(),
7181						r#sponsor: r#sponsor_property.unwrap_or_default(),
7182						r#sub_organization: r#sub_organization_property.unwrap_or_default(),
7183						r#tax_id: r#tax_id_property.unwrap_or_default(),
7184						r#telephone: r#telephone_property.unwrap_or_default(),
7185						r#unnamed_sources_policy: r#unnamed_sources_policy_property
7186							.unwrap_or_default(),
7187						r#vat_id: r#vat_id_property.unwrap_or_default(),
7188						r#additional_property: r#additional_property_property.unwrap_or_default(),
7189						r#amenity_feature: r#amenity_feature_property.unwrap_or_default(),
7190						r#branch_code: r#branch_code_property.unwrap_or_default(),
7191						r#contained_in: r#contained_in_property.unwrap_or_default(),
7192						r#contained_in_place: r#contained_in_place_property.unwrap_or_default(),
7193						r#contains_place: r#contains_place_property.unwrap_or_default(),
7194						r#geo: r#geo_property.unwrap_or_default(),
7195						r#geo_contains: r#geo_contains_property.unwrap_or_default(),
7196						r#geo_covered_by: r#geo_covered_by_property.unwrap_or_default(),
7197						r#geo_covers: r#geo_covers_property.unwrap_or_default(),
7198						r#geo_crosses: r#geo_crosses_property.unwrap_or_default(),
7199						r#geo_disjoint: r#geo_disjoint_property.unwrap_or_default(),
7200						r#geo_equals: r#geo_equals_property.unwrap_or_default(),
7201						r#geo_intersects: r#geo_intersects_property.unwrap_or_default(),
7202						r#geo_overlaps: r#geo_overlaps_property.unwrap_or_default(),
7203						r#geo_touches: r#geo_touches_property.unwrap_or_default(),
7204						r#geo_within: r#geo_within_property.unwrap_or_default(),
7205						r#has_drive_through_service: r#has_drive_through_service_property
7206							.unwrap_or_default(),
7207						r#has_map: r#has_map_property.unwrap_or_default(),
7208						r#is_accessible_for_free: r#is_accessible_for_free_property
7209							.unwrap_or_default(),
7210						r#latitude: r#latitude_property.unwrap_or_default(),
7211						r#longitude: r#longitude_property.unwrap_or_default(),
7212						r#map: r#map_property.unwrap_or_default(),
7213						r#maps: r#maps_property.unwrap_or_default(),
7214						r#maximum_attendee_capacity: r#maximum_attendee_capacity_property
7215							.unwrap_or_default(),
7216						r#opening_hours_specification: r#opening_hours_specification_property
7217							.unwrap_or_default(),
7218						r#photo: r#photo_property.unwrap_or_default(),
7219						r#photos: r#photos_property.unwrap_or_default(),
7220						r#public_access: r#public_access_property.unwrap_or_default(),
7221						r#smoking_allowed: r#smoking_allowed_property.unwrap_or_default(),
7222						r#special_opening_hours_specification:
7223							r#special_opening_hours_specification_property.unwrap_or_default(),
7224						r#tour_booking_page: r#tour_booking_page_property.unwrap_or_default(),
7225						r#additional_type: r#additional_type_property.unwrap_or_default(),
7226						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
7227						r#description: r#description_property.unwrap_or_default(),
7228						r#disambiguating_description: r#disambiguating_description_property
7229							.unwrap_or_default(),
7230						r#identifier: r#identifier_property.unwrap_or_default(),
7231						r#image: r#image_property.unwrap_or_default(),
7232						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
7233						r#name: r#name_property.unwrap_or_default(),
7234						r#potential_action: r#potential_action_property.unwrap_or_default(),
7235						r#same_as: r#same_as_property.unwrap_or_default(),
7236						r#subject_of: r#subject_of_property.unwrap_or_default(),
7237						r#url: r#url_property.unwrap_or_default(),
7238					})
7239				}
7240			}
7241			const FIELDS: &[&str] = &[
7242				"acceptsReservations",
7243				"hasMenu",
7244				"menu",
7245				"servesCuisine",
7246				"starRating",
7247				"branchOf",
7248				"currenciesAccepted",
7249				"openingHours",
7250				"paymentAccepted",
7251				"priceRange",
7252				"actionableFeedbackPolicy",
7253				"address",
7254				"agentInteractionStatistic",
7255				"aggregateRating",
7256				"alumni",
7257				"areaServed",
7258				"award",
7259				"awards",
7260				"brand",
7261				"contactPoint",
7262				"contactPoints",
7263				"correctionsPolicy",
7264				"department",
7265				"dissolutionDate",
7266				"diversityPolicy",
7267				"diversityStaffingReport",
7268				"duns",
7269				"email",
7270				"employee",
7271				"employees",
7272				"ethicsPolicy",
7273				"event",
7274				"events",
7275				"faxNumber",
7276				"founder",
7277				"founders",
7278				"foundingDate",
7279				"foundingLocation",
7280				"funder",
7281				"funding",
7282				"globalLocationNumber",
7283				"hasCredential",
7284				"hasMerchantReturnPolicy",
7285				"hasOfferCatalog",
7286				"hasPOS",
7287				"hasProductReturnPolicy",
7288				"interactionStatistic",
7289				"isicV4",
7290				"iso6523Code",
7291				"keywords",
7292				"knowsAbout",
7293				"knowsLanguage",
7294				"legalName",
7295				"leiCode",
7296				"location",
7297				"logo",
7298				"makesOffer",
7299				"member",
7300				"memberOf",
7301				"members",
7302				"naics",
7303				"nonprofitStatus",
7304				"numberOfEmployees",
7305				"ownershipFundingInfo",
7306				"owns",
7307				"parentOrganization",
7308				"publishingPrinciples",
7309				"review",
7310				"reviews",
7311				"seeks",
7312				"serviceArea",
7313				"slogan",
7314				"sponsor",
7315				"subOrganization",
7316				"taxID",
7317				"telephone",
7318				"unnamedSourcesPolicy",
7319				"vatID",
7320				"additionalProperty",
7321				"amenityFeature",
7322				"branchCode",
7323				"containedIn",
7324				"containedInPlace",
7325				"containsPlace",
7326				"geo",
7327				"geoContains",
7328				"geoCoveredBy",
7329				"geoCovers",
7330				"geoCrosses",
7331				"geoDisjoint",
7332				"geoEquals",
7333				"geoIntersects",
7334				"geoOverlaps",
7335				"geoTouches",
7336				"geoWithin",
7337				"hasDriveThroughService",
7338				"hasMap",
7339				"isAccessibleForFree",
7340				"latitude",
7341				"longitude",
7342				"map",
7343				"maps",
7344				"maximumAttendeeCapacity",
7345				"openingHoursSpecification",
7346				"photo",
7347				"photos",
7348				"publicAccess",
7349				"smokingAllowed",
7350				"specialOpeningHoursSpecification",
7351				"tourBookingPage",
7352				"additionalType",
7353				"alternateName",
7354				"description",
7355				"disambiguatingDescription",
7356				"identifier",
7357				"image",
7358				"mainEntityOfPage",
7359				"name",
7360				"potentialAction",
7361				"sameAs",
7362				"subjectOf",
7363				"url",
7364			];
7365			deserializer.deserialize_struct("IceCreamShop", FIELDS, ClassVisitor)
7366		}
7367	}
7368}
schema_org_types/schemas/classes/ice_cream_shop.rs

schema_org_types/schemas/classes/
ice_cream_shop.rs
