schema_org_types/schemas/classes/
bakery.rs

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

schema_org_types/schemas/classes/
bakery.rs
