schema_org_types/schemas/classes/
fire_station.rs

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

schema_org_types/schemas/classes/
fire_station.rs
