schema_org_types/schemas/classes/
professional_service.rs

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

schema_org_types/schemas/classes/
professional_service.rs
