schema_org_types/schemas/classes/
product_collection.rs

1use super::*;
2/// <https://schema.org/ProductCollection>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct ProductCollection {
6	/// <https://schema.org/includesObject>
7	pub r#includes_object: Vec<IncludesObjectProperty>,
8	/// <https://schema.org/collectionSize>
9	pub r#collection_size: Vec<CollectionSizeProperty>,
10	/// <https://schema.org/about>
11	pub r#about: Vec<AboutProperty>,
12	/// <https://schema.org/abstract>
13	pub r#abstract: Vec<AbstractProperty>,
14	/// <https://schema.org/accessMode>
15	pub r#access_mode: Vec<AccessModeProperty>,
16	/// <https://schema.org/accessModeSufficient>
17	pub r#access_mode_sufficient: Vec<AccessModeSufficientProperty>,
18	/// <https://schema.org/accessibilityAPI>
19	pub r#accessibility_api: Vec<AccessibilityApiProperty>,
20	/// <https://schema.org/accessibilityControl>
21	pub r#accessibility_control: Vec<AccessibilityControlProperty>,
22	/// <https://schema.org/accessibilityFeature>
23	pub r#accessibility_feature: Vec<AccessibilityFeatureProperty>,
24	/// <https://schema.org/accessibilityHazard>
25	pub r#accessibility_hazard: Vec<AccessibilityHazardProperty>,
26	/// <https://schema.org/accessibilitySummary>
27	pub r#accessibility_summary: Vec<AccessibilitySummaryProperty>,
28	/// <https://schema.org/accountablePerson>
29	pub r#accountable_person: Vec<AccountablePersonProperty>,
30	/// <https://schema.org/acquireLicensePage>
31	pub r#acquire_license_page: Vec<AcquireLicensePageProperty>,
32	/// <https://schema.org/aggregateRating>
33	pub r#aggregate_rating: Vec<AggregateRatingProperty>,
34	/// <https://schema.org/alternativeHeadline>
35	pub r#alternative_headline: Vec<AlternativeHeadlineProperty>,
36	/// <https://schema.org/archivedAt>
37	pub r#archived_at: Vec<ArchivedAtProperty>,
38	/// <https://schema.org/assesses>
39	pub r#assesses: Vec<AssessesProperty>,
40	/// <https://schema.org/associatedMedia>
41	pub r#associated_media: Vec<AssociatedMediaProperty>,
42	/// <https://schema.org/audience>
43	pub r#audience: Vec<AudienceProperty>,
44	/// <https://schema.org/audio>
45	pub r#audio: Vec<AudioProperty>,
46	/// <https://schema.org/author>
47	pub r#author: Vec<AuthorProperty>,
48	/// <https://schema.org/award>
49	pub r#award: Vec<AwardProperty>,
50	/// <https://schema.org/awards>
51	#[deprecated = "This schema is superseded by <https://schema.org/award>."]
52	pub r#awards: Vec<AwardsProperty>,
53	/// <https://schema.org/character>
54	pub r#character: Vec<CharacterProperty>,
55	/// <https://schema.org/citation>
56	pub r#citation: Vec<CitationProperty>,
57	/// <https://schema.org/comment>
58	pub r#comment: Vec<CommentProperty>,
59	/// <https://schema.org/commentCount>
60	pub r#comment_count: Vec<CommentCountProperty>,
61	/// <https://schema.org/conditionsOfAccess>
62	pub r#conditions_of_access: Vec<ConditionsOfAccessProperty>,
63	/// <https://schema.org/contentLocation>
64	pub r#content_location: Vec<ContentLocationProperty>,
65	/// <https://schema.org/contentRating>
66	pub r#content_rating: Vec<ContentRatingProperty>,
67	/// <https://schema.org/contentReferenceTime>
68	pub r#content_reference_time: Vec<ContentReferenceTimeProperty>,
69	/// <https://schema.org/contributor>
70	pub r#contributor: Vec<ContributorProperty>,
71	/// <https://schema.org/copyrightHolder>
72	pub r#copyright_holder: Vec<CopyrightHolderProperty>,
73	/// <https://schema.org/copyrightNotice>
74	pub r#copyright_notice: Vec<CopyrightNoticeProperty>,
75	/// <https://schema.org/copyrightYear>
76	pub r#copyright_year: Vec<CopyrightYearProperty>,
77	/// <https://schema.org/correction>
78	pub r#correction: Vec<CorrectionProperty>,
79	/// <https://schema.org/countryOfOrigin>
80	pub r#country_of_origin: Vec<CountryOfOriginProperty>,
81	/// <https://schema.org/creativeWorkStatus>
82	pub r#creative_work_status: Vec<CreativeWorkStatusProperty>,
83	/// <https://schema.org/creator>
84	pub r#creator: Vec<CreatorProperty>,
85	/// <https://schema.org/creditText>
86	pub r#credit_text: Vec<CreditTextProperty>,
87	/// <https://schema.org/dateCreated>
88	pub r#date_created: Vec<DateCreatedProperty>,
89	/// <https://schema.org/dateModified>
90	pub r#date_modified: Vec<DateModifiedProperty>,
91	/// <https://schema.org/datePublished>
92	pub r#date_published: Vec<DatePublishedProperty>,
93	/// <https://schema.org/discussionUrl>
94	pub r#discussion_url: Vec<DiscussionUrlProperty>,
95	/// <https://schema.org/editEIDR>
96	pub r#edit_eidr: Vec<EditEidrProperty>,
97	/// <https://schema.org/editor>
98	pub r#editor: Vec<EditorProperty>,
99	/// <https://schema.org/educationalAlignment>
100	pub r#educational_alignment: Vec<EducationalAlignmentProperty>,
101	/// <https://schema.org/educationalLevel>
102	pub r#educational_level: Vec<EducationalLevelProperty>,
103	/// <https://schema.org/educationalUse>
104	pub r#educational_use: Vec<EducationalUseProperty>,
105	/// <https://schema.org/encoding>
106	pub r#encoding: Vec<EncodingProperty>,
107	/// <https://schema.org/encodingFormat>
108	pub r#encoding_format: Vec<EncodingFormatProperty>,
109	/// <https://schema.org/encodings>
110	#[deprecated = "This schema is superseded by <https://schema.org/encoding>."]
111	pub r#encodings: Vec<EncodingsProperty>,
112	/// <https://schema.org/exampleOfWork>
113	pub r#example_of_work: Vec<ExampleOfWorkProperty>,
114	/// <https://schema.org/expires>
115	pub r#expires: Vec<ExpiresProperty>,
116	/// <https://schema.org/fileFormat>
117	#[deprecated = "This schema is superseded by <https://schema.org/encodingFormat>."]
118	pub r#file_format: Vec<FileFormatProperty>,
119	/// <https://schema.org/funder>
120	pub r#funder: Vec<FunderProperty>,
121	/// <https://schema.org/funding>
122	pub r#funding: Vec<FundingProperty>,
123	/// <https://schema.org/genre>
124	pub r#genre: Vec<GenreProperty>,
125	/// <https://schema.org/hasPart>
126	pub r#has_part: Vec<HasPartProperty>,
127	/// <https://schema.org/headline>
128	pub r#headline: Vec<HeadlineProperty>,
129	/// <https://schema.org/inLanguage>
130	pub r#in_language: Vec<InLanguageProperty>,
131	/// <https://schema.org/interactionStatistic>
132	pub r#interaction_statistic: Vec<InteractionStatisticProperty>,
133	/// <https://schema.org/interactivityType>
134	pub r#interactivity_type: Vec<InteractivityTypeProperty>,
135	/// <https://schema.org/interpretedAsClaim>
136	pub r#interpreted_as_claim: Vec<InterpretedAsClaimProperty>,
137	/// <https://schema.org/isAccessibleForFree>
138	pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
139	/// <https://schema.org/isBasedOn>
140	pub r#is_based_on: Vec<IsBasedOnProperty>,
141	/// <https://schema.org/isBasedOnUrl>
142	#[deprecated = "This schema is superseded by <https://schema.org/isBasedOn>."]
143	pub r#is_based_on_url: Vec<IsBasedOnUrlProperty>,
144	/// <https://schema.org/isFamilyFriendly>
145	pub r#is_family_friendly: Vec<IsFamilyFriendlyProperty>,
146	/// <https://schema.org/isPartOf>
147	pub r#is_part_of: Vec<IsPartOfProperty>,
148	/// <https://schema.org/keywords>
149	pub r#keywords: Vec<KeywordsProperty>,
150	/// <https://schema.org/learningResourceType>
151	pub r#learning_resource_type: Vec<LearningResourceTypeProperty>,
152	/// <https://schema.org/license>
153	pub r#license: Vec<LicenseProperty>,
154	/// <https://schema.org/locationCreated>
155	pub r#location_created: Vec<LocationCreatedProperty>,
156	/// <https://schema.org/mainEntity>
157	pub r#main_entity: Vec<MainEntityProperty>,
158	/// <https://schema.org/maintainer>
159	pub r#maintainer: Vec<MaintainerProperty>,
160	/// <https://schema.org/material>
161	pub r#material: Vec<MaterialProperty>,
162	/// <https://schema.org/materialExtent>
163	pub r#material_extent: Vec<MaterialExtentProperty>,
164	/// <https://schema.org/mentions>
165	pub r#mentions: Vec<MentionsProperty>,
166	/// <https://schema.org/offers>
167	pub r#offers: Vec<OffersProperty>,
168	/// <https://schema.org/pattern>
169	pub r#pattern: Vec<PatternProperty>,
170	/// <https://schema.org/position>
171	pub r#position: Vec<PositionProperty>,
172	/// <https://schema.org/producer>
173	pub r#producer: Vec<ProducerProperty>,
174	/// <https://schema.org/provider>
175	pub r#provider: Vec<ProviderProperty>,
176	/// <https://schema.org/publication>
177	pub r#publication: Vec<PublicationProperty>,
178	/// <https://schema.org/publisher>
179	pub r#publisher: Vec<PublisherProperty>,
180	/// <https://schema.org/publisherImprint>
181	pub r#publisher_imprint: Vec<PublisherImprintProperty>,
182	/// <https://schema.org/publishingPrinciples>
183	pub r#publishing_principles: Vec<PublishingPrinciplesProperty>,
184	/// <https://schema.org/recordedAt>
185	pub r#recorded_at: Vec<RecordedAtProperty>,
186	/// <https://schema.org/releasedEvent>
187	pub r#released_event: Vec<ReleasedEventProperty>,
188	/// <https://schema.org/review>
189	pub r#review: Vec<ReviewProperty>,
190	/// <https://schema.org/reviews>
191	#[deprecated = "This schema is superseded by <https://schema.org/review>."]
192	pub r#reviews: Vec<ReviewsProperty>,
193	/// <https://schema.org/schemaVersion>
194	pub r#schema_version: Vec<SchemaVersionProperty>,
195	/// <https://schema.org/sdDatePublished>
196	pub r#sd_date_published: Vec<SdDatePublishedProperty>,
197	/// <https://schema.org/sdLicense>
198	pub r#sd_license: Vec<SdLicenseProperty>,
199	/// <https://schema.org/sdPublisher>
200	pub r#sd_publisher: Vec<SdPublisherProperty>,
201	/// <https://schema.org/size>
202	pub r#size: Vec<SizeProperty>,
203	/// <https://schema.org/sourceOrganization>
204	pub r#source_organization: Vec<SourceOrganizationProperty>,
205	/// <https://schema.org/spatial>
206	pub r#spatial: Vec<SpatialProperty>,
207	/// <https://schema.org/spatialCoverage>
208	pub r#spatial_coverage: Vec<SpatialCoverageProperty>,
209	/// <https://schema.org/sponsor>
210	pub r#sponsor: Vec<SponsorProperty>,
211	/// <https://schema.org/teaches>
212	pub r#teaches: Vec<TeachesProperty>,
213	/// <https://schema.org/temporal>
214	pub r#temporal: Vec<TemporalProperty>,
215	/// <https://schema.org/temporalCoverage>
216	pub r#temporal_coverage: Vec<TemporalCoverageProperty>,
217	/// <https://schema.org/text>
218	pub r#text: Vec<TextProperty>,
219	/// <https://schema.org/thumbnail>
220	pub r#thumbnail: Vec<ThumbnailProperty>,
221	/// <https://schema.org/thumbnailUrl>
222	pub r#thumbnail_url: Vec<ThumbnailUrlProperty>,
223	/// <https://schema.org/timeRequired>
224	pub r#time_required: Vec<TimeRequiredProperty>,
225	/// <https://schema.org/translationOfWork>
226	pub r#translation_of_work: Vec<TranslationOfWorkProperty>,
227	/// <https://schema.org/translator>
228	pub r#translator: Vec<TranslatorProperty>,
229	/// <https://schema.org/typicalAgeRange>
230	pub r#typical_age_range: Vec<TypicalAgeRangeProperty>,
231	/// <https://schema.org/usageInfo>
232	pub r#usage_info: Vec<UsageInfoProperty>,
233	/// <https://schema.org/version>
234	pub r#version: Vec<VersionProperty>,
235	/// <https://schema.org/video>
236	pub r#video: Vec<VideoProperty>,
237	/// <https://schema.org/workExample>
238	pub r#work_example: Vec<WorkExampleProperty>,
239	/// <https://schema.org/workTranslation>
240	pub r#work_translation: Vec<WorkTranslationProperty>,
241	/// <https://schema.org/additionalProperty>
242	pub r#additional_property: Vec<AdditionalPropertyProperty>,
243	/// <https://schema.org/asin>
244	pub r#asin: Vec<AsinProperty>,
245	/// <https://schema.org/brand>
246	pub r#brand: Vec<BrandProperty>,
247	/// <https://schema.org/category>
248	pub r#category: Vec<CategoryProperty>,
249	/// <https://schema.org/color>
250	pub r#color: Vec<ColorProperty>,
251	/// <https://schema.org/countryOfAssembly>
252	pub r#country_of_assembly: Vec<CountryOfAssemblyProperty>,
253	/// <https://schema.org/countryOfLastProcessing>
254	pub r#country_of_last_processing: Vec<CountryOfLastProcessingProperty>,
255	/// <https://schema.org/depth>
256	pub r#depth: Vec<DepthProperty>,
257	/// <https://schema.org/gtin>
258	pub r#gtin: Vec<GtinProperty>,
259	/// <https://schema.org/gtin12>
260	pub r#gtin_12: Vec<Gtin12Property>,
261	/// <https://schema.org/gtin13>
262	pub r#gtin_13: Vec<Gtin13Property>,
263	/// <https://schema.org/gtin14>
264	pub r#gtin_14: Vec<Gtin14Property>,
265	/// <https://schema.org/gtin8>
266	pub r#gtin_8: Vec<Gtin8Property>,
267	/// <https://schema.org/hasAdultConsideration>
268	pub r#has_adult_consideration: Vec<HasAdultConsiderationProperty>,
269	/// <https://schema.org/hasEnergyConsumptionDetails>
270	pub r#has_energy_consumption_details: Vec<HasEnergyConsumptionDetailsProperty>,
271	/// <https://schema.org/hasMeasurement>
272	pub r#has_measurement: Vec<HasMeasurementProperty>,
273	/// <https://schema.org/hasMerchantReturnPolicy>
274	pub r#has_merchant_return_policy: Vec<HasMerchantReturnPolicyProperty>,
275	/// <https://schema.org/hasProductReturnPolicy>
276	#[deprecated = "This schema is archived, see <https://schema.org/docs/attic.home.html>. This schema is superseded by <https://schema.org/hasMerchantReturnPolicy>."]
277	pub r#has_product_return_policy: Vec<HasProductReturnPolicyProperty>,
278	/// <https://schema.org/height>
279	pub r#height: Vec<HeightProperty>,
280	/// <https://schema.org/inProductGroupWithID>
281	pub r#in_product_group_with_id: Vec<InProductGroupWithIdProperty>,
282	/// <https://schema.org/isAccessoryOrSparePartFor>
283	pub r#is_accessory_or_spare_part_for: Vec<IsAccessoryOrSparePartForProperty>,
284	/// <https://schema.org/isConsumableFor>
285	pub r#is_consumable_for: Vec<IsConsumableForProperty>,
286	/// <https://schema.org/isRelatedTo>
287	pub r#is_related_to: Vec<IsRelatedToProperty>,
288	/// <https://schema.org/isSimilarTo>
289	pub r#is_similar_to: Vec<IsSimilarToProperty>,
290	/// <https://schema.org/isVariantOf>
291	pub r#is_variant_of: Vec<IsVariantOfProperty>,
292	/// <https://schema.org/itemCondition>
293	pub r#item_condition: Vec<ItemConditionProperty>,
294	/// <https://schema.org/logo>
295	pub r#logo: Vec<LogoProperty>,
296	/// <https://schema.org/manufacturer>
297	pub r#manufacturer: Vec<ManufacturerProperty>,
298	/// <https://schema.org/mobileUrl>
299	pub r#mobile_url: Vec<MobileUrlProperty>,
300	/// <https://schema.org/model>
301	pub r#model: Vec<ModelProperty>,
302	/// <https://schema.org/mpn>
303	pub r#mpn: Vec<MpnProperty>,
304	/// <https://schema.org/negativeNotes>
305	pub r#negative_notes: Vec<NegativeNotesProperty>,
306	/// <https://schema.org/nsn>
307	pub r#nsn: Vec<NsnProperty>,
308	/// <https://schema.org/positiveNotes>
309	pub r#positive_notes: Vec<PositiveNotesProperty>,
310	/// <https://schema.org/productID>
311	pub r#product_id: Vec<ProductIdProperty>,
312	/// <https://schema.org/productionDate>
313	pub r#production_date: Vec<ProductionDateProperty>,
314	/// <https://schema.org/purchaseDate>
315	pub r#purchase_date: Vec<PurchaseDateProperty>,
316	/// <https://schema.org/releaseDate>
317	pub r#release_date: Vec<ReleaseDateProperty>,
318	/// <https://schema.org/sku>
319	pub r#sku: Vec<SkuProperty>,
320	/// <https://schema.org/slogan>
321	pub r#slogan: Vec<SloganProperty>,
322	/// <https://schema.org/weight>
323	pub r#weight: Vec<WeightProperty>,
324	/// <https://schema.org/width>
325	pub r#width: Vec<WidthProperty>,
326	/// <https://schema.org/additionalType>
327	pub r#additional_type: Vec<AdditionalTypeProperty>,
328	/// <https://schema.org/alternateName>
329	pub r#alternate_name: Vec<AlternateNameProperty>,
330	/// <https://schema.org/description>
331	pub r#description: Vec<DescriptionProperty>,
332	/// <https://schema.org/disambiguatingDescription>
333	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
334	/// <https://schema.org/identifier>
335	pub r#identifier: Vec<IdentifierProperty>,
336	/// <https://schema.org/image>
337	pub r#image: Vec<ImageProperty>,
338	/// <https://schema.org/mainEntityOfPage>
339	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
340	/// <https://schema.org/name>
341	pub r#name: Vec<NameProperty>,
342	/// <https://schema.org/potentialAction>
343	pub r#potential_action: Vec<PotentialActionProperty>,
344	/// <https://schema.org/sameAs>
345	pub r#same_as: Vec<SameAsProperty>,
346	/// <https://schema.org/subjectOf>
347	pub r#subject_of: Vec<SubjectOfProperty>,
348	/// <https://schema.org/url>
349	pub r#url: Vec<UrlProperty>,
350}
351/// This trait is for properties from <https://schema.org/ProductCollection>.
352pub trait ProductCollectionTrait {
353	/// Get <https://schema.org/includesObject> from [`Self`] as borrowed slice.
354	fn get_includes_object(&self) -> &[IncludesObjectProperty];
355	/// Take <https://schema.org/includesObject> from [`Self`] as owned vector.
356	fn take_includes_object(&mut self) -> Vec<IncludesObjectProperty>;
357}
358impl ProductCollectionTrait for ProductCollection {
359	fn get_includes_object(&self) -> &[IncludesObjectProperty] {
360		self.r#includes_object.as_slice()
361	}
362	fn take_includes_object(&mut self) -> Vec<IncludesObjectProperty> {
363		std::mem::take(&mut self.r#includes_object)
364	}
365}
366impl CollectionTrait for ProductCollection {
367	fn get_collection_size(&self) -> &[CollectionSizeProperty] {
368		self.r#collection_size.as_slice()
369	}
370	fn take_collection_size(&mut self) -> Vec<CollectionSizeProperty> {
371		std::mem::take(&mut self.r#collection_size)
372	}
373}
374impl CreativeWorkTrait for ProductCollection {
375	fn get_about(&self) -> &[AboutProperty] {
376		self.r#about.as_slice()
377	}
378	fn take_about(&mut self) -> Vec<AboutProperty> {
379		std::mem::take(&mut self.r#about)
380	}
381	fn get_abstract(&self) -> &[AbstractProperty] {
382		self.r#abstract.as_slice()
383	}
384	fn take_abstract(&mut self) -> Vec<AbstractProperty> {
385		std::mem::take(&mut self.r#abstract)
386	}
387	fn get_access_mode(&self) -> &[AccessModeProperty] {
388		self.r#access_mode.as_slice()
389	}
390	fn take_access_mode(&mut self) -> Vec<AccessModeProperty> {
391		std::mem::take(&mut self.r#access_mode)
392	}
393	fn get_access_mode_sufficient(&self) -> &[AccessModeSufficientProperty] {
394		self.r#access_mode_sufficient.as_slice()
395	}
396	fn take_access_mode_sufficient(&mut self) -> Vec<AccessModeSufficientProperty> {
397		std::mem::take(&mut self.r#access_mode_sufficient)
398	}
399	fn get_accessibility_api(&self) -> &[AccessibilityApiProperty] {
400		self.r#accessibility_api.as_slice()
401	}
402	fn take_accessibility_api(&mut self) -> Vec<AccessibilityApiProperty> {
403		std::mem::take(&mut self.r#accessibility_api)
404	}
405	fn get_accessibility_control(&self) -> &[AccessibilityControlProperty] {
406		self.r#accessibility_control.as_slice()
407	}
408	fn take_accessibility_control(&mut self) -> Vec<AccessibilityControlProperty> {
409		std::mem::take(&mut self.r#accessibility_control)
410	}
411	fn get_accessibility_feature(&self) -> &[AccessibilityFeatureProperty] {
412		self.r#accessibility_feature.as_slice()
413	}
414	fn take_accessibility_feature(&mut self) -> Vec<AccessibilityFeatureProperty> {
415		std::mem::take(&mut self.r#accessibility_feature)
416	}
417	fn get_accessibility_hazard(&self) -> &[AccessibilityHazardProperty] {
418		self.r#accessibility_hazard.as_slice()
419	}
420	fn take_accessibility_hazard(&mut self) -> Vec<AccessibilityHazardProperty> {
421		std::mem::take(&mut self.r#accessibility_hazard)
422	}
423	fn get_accessibility_summary(&self) -> &[AccessibilitySummaryProperty] {
424		self.r#accessibility_summary.as_slice()
425	}
426	fn take_accessibility_summary(&mut self) -> Vec<AccessibilitySummaryProperty> {
427		std::mem::take(&mut self.r#accessibility_summary)
428	}
429	fn get_accountable_person(&self) -> &[AccountablePersonProperty] {
430		self.r#accountable_person.as_slice()
431	}
432	fn take_accountable_person(&mut self) -> Vec<AccountablePersonProperty> {
433		std::mem::take(&mut self.r#accountable_person)
434	}
435	fn get_acquire_license_page(&self) -> &[AcquireLicensePageProperty] {
436		self.r#acquire_license_page.as_slice()
437	}
438	fn take_acquire_license_page(&mut self) -> Vec<AcquireLicensePageProperty> {
439		std::mem::take(&mut self.r#acquire_license_page)
440	}
441	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
442		self.r#aggregate_rating.as_slice()
443	}
444	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
445		std::mem::take(&mut self.r#aggregate_rating)
446	}
447	fn get_alternative_headline(&self) -> &[AlternativeHeadlineProperty] {
448		self.r#alternative_headline.as_slice()
449	}
450	fn take_alternative_headline(&mut self) -> Vec<AlternativeHeadlineProperty> {
451		std::mem::take(&mut self.r#alternative_headline)
452	}
453	fn get_archived_at(&self) -> &[ArchivedAtProperty] {
454		self.r#archived_at.as_slice()
455	}
456	fn take_archived_at(&mut self) -> Vec<ArchivedAtProperty> {
457		std::mem::take(&mut self.r#archived_at)
458	}
459	fn get_assesses(&self) -> &[AssessesProperty] {
460		self.r#assesses.as_slice()
461	}
462	fn take_assesses(&mut self) -> Vec<AssessesProperty> {
463		std::mem::take(&mut self.r#assesses)
464	}
465	fn get_associated_media(&self) -> &[AssociatedMediaProperty] {
466		self.r#associated_media.as_slice()
467	}
468	fn take_associated_media(&mut self) -> Vec<AssociatedMediaProperty> {
469		std::mem::take(&mut self.r#associated_media)
470	}
471	fn get_audience(&self) -> &[AudienceProperty] {
472		self.r#audience.as_slice()
473	}
474	fn take_audience(&mut self) -> Vec<AudienceProperty> {
475		std::mem::take(&mut self.r#audience)
476	}
477	fn get_audio(&self) -> &[AudioProperty] {
478		self.r#audio.as_slice()
479	}
480	fn take_audio(&mut self) -> Vec<AudioProperty> {
481		std::mem::take(&mut self.r#audio)
482	}
483	fn get_author(&self) -> &[AuthorProperty] {
484		self.r#author.as_slice()
485	}
486	fn take_author(&mut self) -> Vec<AuthorProperty> {
487		std::mem::take(&mut self.r#author)
488	}
489	fn get_award(&self) -> &[AwardProperty] {
490		self.r#award.as_slice()
491	}
492	fn take_award(&mut self) -> Vec<AwardProperty> {
493		std::mem::take(&mut self.r#award)
494	}
495	fn get_awards(&self) -> &[AwardsProperty] {
496		self.r#awards.as_slice()
497	}
498	fn take_awards(&mut self) -> Vec<AwardsProperty> {
499		std::mem::take(&mut self.r#awards)
500	}
501	fn get_character(&self) -> &[CharacterProperty] {
502		self.r#character.as_slice()
503	}
504	fn take_character(&mut self) -> Vec<CharacterProperty> {
505		std::mem::take(&mut self.r#character)
506	}
507	fn get_citation(&self) -> &[CitationProperty] {
508		self.r#citation.as_slice()
509	}
510	fn take_citation(&mut self) -> Vec<CitationProperty> {
511		std::mem::take(&mut self.r#citation)
512	}
513	fn get_comment(&self) -> &[CommentProperty] {
514		self.r#comment.as_slice()
515	}
516	fn take_comment(&mut self) -> Vec<CommentProperty> {
517		std::mem::take(&mut self.r#comment)
518	}
519	fn get_comment_count(&self) -> &[CommentCountProperty] {
520		self.r#comment_count.as_slice()
521	}
522	fn take_comment_count(&mut self) -> Vec<CommentCountProperty> {
523		std::mem::take(&mut self.r#comment_count)
524	}
525	fn get_conditions_of_access(&self) -> &[ConditionsOfAccessProperty] {
526		self.r#conditions_of_access.as_slice()
527	}
528	fn take_conditions_of_access(&mut self) -> Vec<ConditionsOfAccessProperty> {
529		std::mem::take(&mut self.r#conditions_of_access)
530	}
531	fn get_content_location(&self) -> &[ContentLocationProperty] {
532		self.r#content_location.as_slice()
533	}
534	fn take_content_location(&mut self) -> Vec<ContentLocationProperty> {
535		std::mem::take(&mut self.r#content_location)
536	}
537	fn get_content_rating(&self) -> &[ContentRatingProperty] {
538		self.r#content_rating.as_slice()
539	}
540	fn take_content_rating(&mut self) -> Vec<ContentRatingProperty> {
541		std::mem::take(&mut self.r#content_rating)
542	}
543	fn get_content_reference_time(&self) -> &[ContentReferenceTimeProperty] {
544		self.r#content_reference_time.as_slice()
545	}
546	fn take_content_reference_time(&mut self) -> Vec<ContentReferenceTimeProperty> {
547		std::mem::take(&mut self.r#content_reference_time)
548	}
549	fn get_contributor(&self) -> &[ContributorProperty] {
550		self.r#contributor.as_slice()
551	}
552	fn take_contributor(&mut self) -> Vec<ContributorProperty> {
553		std::mem::take(&mut self.r#contributor)
554	}
555	fn get_copyright_holder(&self) -> &[CopyrightHolderProperty] {
556		self.r#copyright_holder.as_slice()
557	}
558	fn take_copyright_holder(&mut self) -> Vec<CopyrightHolderProperty> {
559		std::mem::take(&mut self.r#copyright_holder)
560	}
561	fn get_copyright_notice(&self) -> &[CopyrightNoticeProperty] {
562		self.r#copyright_notice.as_slice()
563	}
564	fn take_copyright_notice(&mut self) -> Vec<CopyrightNoticeProperty> {
565		std::mem::take(&mut self.r#copyright_notice)
566	}
567	fn get_copyright_year(&self) -> &[CopyrightYearProperty] {
568		self.r#copyright_year.as_slice()
569	}
570	fn take_copyright_year(&mut self) -> Vec<CopyrightYearProperty> {
571		std::mem::take(&mut self.r#copyright_year)
572	}
573	fn get_correction(&self) -> &[CorrectionProperty] {
574		self.r#correction.as_slice()
575	}
576	fn take_correction(&mut self) -> Vec<CorrectionProperty> {
577		std::mem::take(&mut self.r#correction)
578	}
579	fn get_country_of_origin(&self) -> &[CountryOfOriginProperty] {
580		self.r#country_of_origin.as_slice()
581	}
582	fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty> {
583		std::mem::take(&mut self.r#country_of_origin)
584	}
585	fn get_creative_work_status(&self) -> &[CreativeWorkStatusProperty] {
586		self.r#creative_work_status.as_slice()
587	}
588	fn take_creative_work_status(&mut self) -> Vec<CreativeWorkStatusProperty> {
589		std::mem::take(&mut self.r#creative_work_status)
590	}
591	fn get_creator(&self) -> &[CreatorProperty] {
592		self.r#creator.as_slice()
593	}
594	fn take_creator(&mut self) -> Vec<CreatorProperty> {
595		std::mem::take(&mut self.r#creator)
596	}
597	fn get_credit_text(&self) -> &[CreditTextProperty] {
598		self.r#credit_text.as_slice()
599	}
600	fn take_credit_text(&mut self) -> Vec<CreditTextProperty> {
601		std::mem::take(&mut self.r#credit_text)
602	}
603	fn get_date_created(&self) -> &[DateCreatedProperty] {
604		self.r#date_created.as_slice()
605	}
606	fn take_date_created(&mut self) -> Vec<DateCreatedProperty> {
607		std::mem::take(&mut self.r#date_created)
608	}
609	fn get_date_modified(&self) -> &[DateModifiedProperty] {
610		self.r#date_modified.as_slice()
611	}
612	fn take_date_modified(&mut self) -> Vec<DateModifiedProperty> {
613		std::mem::take(&mut self.r#date_modified)
614	}
615	fn get_date_published(&self) -> &[DatePublishedProperty] {
616		self.r#date_published.as_slice()
617	}
618	fn take_date_published(&mut self) -> Vec<DatePublishedProperty> {
619		std::mem::take(&mut self.r#date_published)
620	}
621	fn get_discussion_url(&self) -> &[DiscussionUrlProperty] {
622		self.r#discussion_url.as_slice()
623	}
624	fn take_discussion_url(&mut self) -> Vec<DiscussionUrlProperty> {
625		std::mem::take(&mut self.r#discussion_url)
626	}
627	fn get_edit_eidr(&self) -> &[EditEidrProperty] {
628		self.r#edit_eidr.as_slice()
629	}
630	fn take_edit_eidr(&mut self) -> Vec<EditEidrProperty> {
631		std::mem::take(&mut self.r#edit_eidr)
632	}
633	fn get_editor(&self) -> &[EditorProperty] {
634		self.r#editor.as_slice()
635	}
636	fn take_editor(&mut self) -> Vec<EditorProperty> {
637		std::mem::take(&mut self.r#editor)
638	}
639	fn get_educational_alignment(&self) -> &[EducationalAlignmentProperty] {
640		self.r#educational_alignment.as_slice()
641	}
642	fn take_educational_alignment(&mut self) -> Vec<EducationalAlignmentProperty> {
643		std::mem::take(&mut self.r#educational_alignment)
644	}
645	fn get_educational_level(&self) -> &[EducationalLevelProperty] {
646		self.r#educational_level.as_slice()
647	}
648	fn take_educational_level(&mut self) -> Vec<EducationalLevelProperty> {
649		std::mem::take(&mut self.r#educational_level)
650	}
651	fn get_educational_use(&self) -> &[EducationalUseProperty] {
652		self.r#educational_use.as_slice()
653	}
654	fn take_educational_use(&mut self) -> Vec<EducationalUseProperty> {
655		std::mem::take(&mut self.r#educational_use)
656	}
657	fn get_encoding(&self) -> &[EncodingProperty] {
658		self.r#encoding.as_slice()
659	}
660	fn take_encoding(&mut self) -> Vec<EncodingProperty> {
661		std::mem::take(&mut self.r#encoding)
662	}
663	fn get_encoding_format(&self) -> &[EncodingFormatProperty] {
664		self.r#encoding_format.as_slice()
665	}
666	fn take_encoding_format(&mut self) -> Vec<EncodingFormatProperty> {
667		std::mem::take(&mut self.r#encoding_format)
668	}
669	fn get_encodings(&self) -> &[EncodingsProperty] {
670		self.r#encodings.as_slice()
671	}
672	fn take_encodings(&mut self) -> Vec<EncodingsProperty> {
673		std::mem::take(&mut self.r#encodings)
674	}
675	fn get_example_of_work(&self) -> &[ExampleOfWorkProperty] {
676		self.r#example_of_work.as_slice()
677	}
678	fn take_example_of_work(&mut self) -> Vec<ExampleOfWorkProperty> {
679		std::mem::take(&mut self.r#example_of_work)
680	}
681	fn get_expires(&self) -> &[ExpiresProperty] {
682		self.r#expires.as_slice()
683	}
684	fn take_expires(&mut self) -> Vec<ExpiresProperty> {
685		std::mem::take(&mut self.r#expires)
686	}
687	fn get_file_format(&self) -> &[FileFormatProperty] {
688		self.r#file_format.as_slice()
689	}
690	fn take_file_format(&mut self) -> Vec<FileFormatProperty> {
691		std::mem::take(&mut self.r#file_format)
692	}
693	fn get_funder(&self) -> &[FunderProperty] {
694		self.r#funder.as_slice()
695	}
696	fn take_funder(&mut self) -> Vec<FunderProperty> {
697		std::mem::take(&mut self.r#funder)
698	}
699	fn get_funding(&self) -> &[FundingProperty] {
700		self.r#funding.as_slice()
701	}
702	fn take_funding(&mut self) -> Vec<FundingProperty> {
703		std::mem::take(&mut self.r#funding)
704	}
705	fn get_genre(&self) -> &[GenreProperty] {
706		self.r#genre.as_slice()
707	}
708	fn take_genre(&mut self) -> Vec<GenreProperty> {
709		std::mem::take(&mut self.r#genre)
710	}
711	fn get_has_part(&self) -> &[HasPartProperty] {
712		self.r#has_part.as_slice()
713	}
714	fn take_has_part(&mut self) -> Vec<HasPartProperty> {
715		std::mem::take(&mut self.r#has_part)
716	}
717	fn get_headline(&self) -> &[HeadlineProperty] {
718		self.r#headline.as_slice()
719	}
720	fn take_headline(&mut self) -> Vec<HeadlineProperty> {
721		std::mem::take(&mut self.r#headline)
722	}
723	fn get_in_language(&self) -> &[InLanguageProperty] {
724		self.r#in_language.as_slice()
725	}
726	fn take_in_language(&mut self) -> Vec<InLanguageProperty> {
727		std::mem::take(&mut self.r#in_language)
728	}
729	fn get_interaction_statistic(&self) -> &[InteractionStatisticProperty] {
730		self.r#interaction_statistic.as_slice()
731	}
732	fn take_interaction_statistic(&mut self) -> Vec<InteractionStatisticProperty> {
733		std::mem::take(&mut self.r#interaction_statistic)
734	}
735	fn get_interactivity_type(&self) -> &[InteractivityTypeProperty] {
736		self.r#interactivity_type.as_slice()
737	}
738	fn take_interactivity_type(&mut self) -> Vec<InteractivityTypeProperty> {
739		std::mem::take(&mut self.r#interactivity_type)
740	}
741	fn get_interpreted_as_claim(&self) -> &[InterpretedAsClaimProperty] {
742		self.r#interpreted_as_claim.as_slice()
743	}
744	fn take_interpreted_as_claim(&mut self) -> Vec<InterpretedAsClaimProperty> {
745		std::mem::take(&mut self.r#interpreted_as_claim)
746	}
747	fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
748		self.r#is_accessible_for_free.as_slice()
749	}
750	fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
751		std::mem::take(&mut self.r#is_accessible_for_free)
752	}
753	fn get_is_based_on(&self) -> &[IsBasedOnProperty] {
754		self.r#is_based_on.as_slice()
755	}
756	fn take_is_based_on(&mut self) -> Vec<IsBasedOnProperty> {
757		std::mem::take(&mut self.r#is_based_on)
758	}
759	fn get_is_based_on_url(&self) -> &[IsBasedOnUrlProperty] {
760		self.r#is_based_on_url.as_slice()
761	}
762	fn take_is_based_on_url(&mut self) -> Vec<IsBasedOnUrlProperty> {
763		std::mem::take(&mut self.r#is_based_on_url)
764	}
765	fn get_is_family_friendly(&self) -> &[IsFamilyFriendlyProperty] {
766		self.r#is_family_friendly.as_slice()
767	}
768	fn take_is_family_friendly(&mut self) -> Vec<IsFamilyFriendlyProperty> {
769		std::mem::take(&mut self.r#is_family_friendly)
770	}
771	fn get_is_part_of(&self) -> &[IsPartOfProperty] {
772		self.r#is_part_of.as_slice()
773	}
774	fn take_is_part_of(&mut self) -> Vec<IsPartOfProperty> {
775		std::mem::take(&mut self.r#is_part_of)
776	}
777	fn get_keywords(&self) -> &[KeywordsProperty] {
778		self.r#keywords.as_slice()
779	}
780	fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
781		std::mem::take(&mut self.r#keywords)
782	}
783	fn get_learning_resource_type(&self) -> &[LearningResourceTypeProperty] {
784		self.r#learning_resource_type.as_slice()
785	}
786	fn take_learning_resource_type(&mut self) -> Vec<LearningResourceTypeProperty> {
787		std::mem::take(&mut self.r#learning_resource_type)
788	}
789	fn get_license(&self) -> &[LicenseProperty] {
790		self.r#license.as_slice()
791	}
792	fn take_license(&mut self) -> Vec<LicenseProperty> {
793		std::mem::take(&mut self.r#license)
794	}
795	fn get_location_created(&self) -> &[LocationCreatedProperty] {
796		self.r#location_created.as_slice()
797	}
798	fn take_location_created(&mut self) -> Vec<LocationCreatedProperty> {
799		std::mem::take(&mut self.r#location_created)
800	}
801	fn get_main_entity(&self) -> &[MainEntityProperty] {
802		self.r#main_entity.as_slice()
803	}
804	fn take_main_entity(&mut self) -> Vec<MainEntityProperty> {
805		std::mem::take(&mut self.r#main_entity)
806	}
807	fn get_maintainer(&self) -> &[MaintainerProperty] {
808		self.r#maintainer.as_slice()
809	}
810	fn take_maintainer(&mut self) -> Vec<MaintainerProperty> {
811		std::mem::take(&mut self.r#maintainer)
812	}
813	fn get_material(&self) -> &[MaterialProperty] {
814		self.r#material.as_slice()
815	}
816	fn take_material(&mut self) -> Vec<MaterialProperty> {
817		std::mem::take(&mut self.r#material)
818	}
819	fn get_material_extent(&self) -> &[MaterialExtentProperty] {
820		self.r#material_extent.as_slice()
821	}
822	fn take_material_extent(&mut self) -> Vec<MaterialExtentProperty> {
823		std::mem::take(&mut self.r#material_extent)
824	}
825	fn get_mentions(&self) -> &[MentionsProperty] {
826		self.r#mentions.as_slice()
827	}
828	fn take_mentions(&mut self) -> Vec<MentionsProperty> {
829		std::mem::take(&mut self.r#mentions)
830	}
831	fn get_offers(&self) -> &[OffersProperty] {
832		self.r#offers.as_slice()
833	}
834	fn take_offers(&mut self) -> Vec<OffersProperty> {
835		std::mem::take(&mut self.r#offers)
836	}
837	fn get_pattern(&self) -> &[PatternProperty] {
838		self.r#pattern.as_slice()
839	}
840	fn take_pattern(&mut self) -> Vec<PatternProperty> {
841		std::mem::take(&mut self.r#pattern)
842	}
843	fn get_position(&self) -> &[PositionProperty] {
844		self.r#position.as_slice()
845	}
846	fn take_position(&mut self) -> Vec<PositionProperty> {
847		std::mem::take(&mut self.r#position)
848	}
849	fn get_producer(&self) -> &[ProducerProperty] {
850		self.r#producer.as_slice()
851	}
852	fn take_producer(&mut self) -> Vec<ProducerProperty> {
853		std::mem::take(&mut self.r#producer)
854	}
855	fn get_provider(&self) -> &[ProviderProperty] {
856		self.r#provider.as_slice()
857	}
858	fn take_provider(&mut self) -> Vec<ProviderProperty> {
859		std::mem::take(&mut self.r#provider)
860	}
861	fn get_publication(&self) -> &[PublicationProperty] {
862		self.r#publication.as_slice()
863	}
864	fn take_publication(&mut self) -> Vec<PublicationProperty> {
865		std::mem::take(&mut self.r#publication)
866	}
867	fn get_publisher(&self) -> &[PublisherProperty] {
868		self.r#publisher.as_slice()
869	}
870	fn take_publisher(&mut self) -> Vec<PublisherProperty> {
871		std::mem::take(&mut self.r#publisher)
872	}
873	fn get_publisher_imprint(&self) -> &[PublisherImprintProperty] {
874		self.r#publisher_imprint.as_slice()
875	}
876	fn take_publisher_imprint(&mut self) -> Vec<PublisherImprintProperty> {
877		std::mem::take(&mut self.r#publisher_imprint)
878	}
879	fn get_publishing_principles(&self) -> &[PublishingPrinciplesProperty] {
880		self.r#publishing_principles.as_slice()
881	}
882	fn take_publishing_principles(&mut self) -> Vec<PublishingPrinciplesProperty> {
883		std::mem::take(&mut self.r#publishing_principles)
884	}
885	fn get_recorded_at(&self) -> &[RecordedAtProperty] {
886		self.r#recorded_at.as_slice()
887	}
888	fn take_recorded_at(&mut self) -> Vec<RecordedAtProperty> {
889		std::mem::take(&mut self.r#recorded_at)
890	}
891	fn get_released_event(&self) -> &[ReleasedEventProperty] {
892		self.r#released_event.as_slice()
893	}
894	fn take_released_event(&mut self) -> Vec<ReleasedEventProperty> {
895		std::mem::take(&mut self.r#released_event)
896	}
897	fn get_review(&self) -> &[ReviewProperty] {
898		self.r#review.as_slice()
899	}
900	fn take_review(&mut self) -> Vec<ReviewProperty> {
901		std::mem::take(&mut self.r#review)
902	}
903	fn get_reviews(&self) -> &[ReviewsProperty] {
904		self.r#reviews.as_slice()
905	}
906	fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
907		std::mem::take(&mut self.r#reviews)
908	}
909	fn get_schema_version(&self) -> &[SchemaVersionProperty] {
910		self.r#schema_version.as_slice()
911	}
912	fn take_schema_version(&mut self) -> Vec<SchemaVersionProperty> {
913		std::mem::take(&mut self.r#schema_version)
914	}
915	fn get_sd_date_published(&self) -> &[SdDatePublishedProperty] {
916		self.r#sd_date_published.as_slice()
917	}
918	fn take_sd_date_published(&mut self) -> Vec<SdDatePublishedProperty> {
919		std::mem::take(&mut self.r#sd_date_published)
920	}
921	fn get_sd_license(&self) -> &[SdLicenseProperty] {
922		self.r#sd_license.as_slice()
923	}
924	fn take_sd_license(&mut self) -> Vec<SdLicenseProperty> {
925		std::mem::take(&mut self.r#sd_license)
926	}
927	fn get_sd_publisher(&self) -> &[SdPublisherProperty] {
928		self.r#sd_publisher.as_slice()
929	}
930	fn take_sd_publisher(&mut self) -> Vec<SdPublisherProperty> {
931		std::mem::take(&mut self.r#sd_publisher)
932	}
933	fn get_size(&self) -> &[SizeProperty] {
934		self.r#size.as_slice()
935	}
936	fn take_size(&mut self) -> Vec<SizeProperty> {
937		std::mem::take(&mut self.r#size)
938	}
939	fn get_source_organization(&self) -> &[SourceOrganizationProperty] {
940		self.r#source_organization.as_slice()
941	}
942	fn take_source_organization(&mut self) -> Vec<SourceOrganizationProperty> {
943		std::mem::take(&mut self.r#source_organization)
944	}
945	fn get_spatial(&self) -> &[SpatialProperty] {
946		self.r#spatial.as_slice()
947	}
948	fn take_spatial(&mut self) -> Vec<SpatialProperty> {
949		std::mem::take(&mut self.r#spatial)
950	}
951	fn get_spatial_coverage(&self) -> &[SpatialCoverageProperty] {
952		self.r#spatial_coverage.as_slice()
953	}
954	fn take_spatial_coverage(&mut self) -> Vec<SpatialCoverageProperty> {
955		std::mem::take(&mut self.r#spatial_coverage)
956	}
957	fn get_sponsor(&self) -> &[SponsorProperty] {
958		self.r#sponsor.as_slice()
959	}
960	fn take_sponsor(&mut self) -> Vec<SponsorProperty> {
961		std::mem::take(&mut self.r#sponsor)
962	}
963	fn get_teaches(&self) -> &[TeachesProperty] {
964		self.r#teaches.as_slice()
965	}
966	fn take_teaches(&mut self) -> Vec<TeachesProperty> {
967		std::mem::take(&mut self.r#teaches)
968	}
969	fn get_temporal(&self) -> &[TemporalProperty] {
970		self.r#temporal.as_slice()
971	}
972	fn take_temporal(&mut self) -> Vec<TemporalProperty> {
973		std::mem::take(&mut self.r#temporal)
974	}
975	fn get_temporal_coverage(&self) -> &[TemporalCoverageProperty] {
976		self.r#temporal_coverage.as_slice()
977	}
978	fn take_temporal_coverage(&mut self) -> Vec<TemporalCoverageProperty> {
979		std::mem::take(&mut self.r#temporal_coverage)
980	}
981	fn get_text(&self) -> &[TextProperty] {
982		self.r#text.as_slice()
983	}
984	fn take_text(&mut self) -> Vec<TextProperty> {
985		std::mem::take(&mut self.r#text)
986	}
987	fn get_thumbnail(&self) -> &[ThumbnailProperty] {
988		self.r#thumbnail.as_slice()
989	}
990	fn take_thumbnail(&mut self) -> Vec<ThumbnailProperty> {
991		std::mem::take(&mut self.r#thumbnail)
992	}
993	fn get_thumbnail_url(&self) -> &[ThumbnailUrlProperty] {
994		self.r#thumbnail_url.as_slice()
995	}
996	fn take_thumbnail_url(&mut self) -> Vec<ThumbnailUrlProperty> {
997		std::mem::take(&mut self.r#thumbnail_url)
998	}
999	fn get_time_required(&self) -> &[TimeRequiredProperty] {
1000		self.r#time_required.as_slice()
1001	}
1002	fn take_time_required(&mut self) -> Vec<TimeRequiredProperty> {
1003		std::mem::take(&mut self.r#time_required)
1004	}
1005	fn get_translation_of_work(&self) -> &[TranslationOfWorkProperty] {
1006		self.r#translation_of_work.as_slice()
1007	}
1008	fn take_translation_of_work(&mut self) -> Vec<TranslationOfWorkProperty> {
1009		std::mem::take(&mut self.r#translation_of_work)
1010	}
1011	fn get_translator(&self) -> &[TranslatorProperty] {
1012		self.r#translator.as_slice()
1013	}
1014	fn take_translator(&mut self) -> Vec<TranslatorProperty> {
1015		std::mem::take(&mut self.r#translator)
1016	}
1017	fn get_typical_age_range(&self) -> &[TypicalAgeRangeProperty] {
1018		self.r#typical_age_range.as_slice()
1019	}
1020	fn take_typical_age_range(&mut self) -> Vec<TypicalAgeRangeProperty> {
1021		std::mem::take(&mut self.r#typical_age_range)
1022	}
1023	fn get_usage_info(&self) -> &[UsageInfoProperty] {
1024		self.r#usage_info.as_slice()
1025	}
1026	fn take_usage_info(&mut self) -> Vec<UsageInfoProperty> {
1027		std::mem::take(&mut self.r#usage_info)
1028	}
1029	fn get_version(&self) -> &[VersionProperty] {
1030		self.r#version.as_slice()
1031	}
1032	fn take_version(&mut self) -> Vec<VersionProperty> {
1033		std::mem::take(&mut self.r#version)
1034	}
1035	fn get_video(&self) -> &[VideoProperty] {
1036		self.r#video.as_slice()
1037	}
1038	fn take_video(&mut self) -> Vec<VideoProperty> {
1039		std::mem::take(&mut self.r#video)
1040	}
1041	fn get_work_example(&self) -> &[WorkExampleProperty] {
1042		self.r#work_example.as_slice()
1043	}
1044	fn take_work_example(&mut self) -> Vec<WorkExampleProperty> {
1045		std::mem::take(&mut self.r#work_example)
1046	}
1047	fn get_work_translation(&self) -> &[WorkTranslationProperty] {
1048		self.r#work_translation.as_slice()
1049	}
1050	fn take_work_translation(&mut self) -> Vec<WorkTranslationProperty> {
1051		std::mem::take(&mut self.r#work_translation)
1052	}
1053}
1054impl ProductTrait for ProductCollection {
1055	fn get_additional_property(&self) -> &[AdditionalPropertyProperty] {
1056		self.r#additional_property.as_slice()
1057	}
1058	fn take_additional_property(&mut self) -> Vec<AdditionalPropertyProperty> {
1059		std::mem::take(&mut self.r#additional_property)
1060	}
1061	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
1062		self.r#aggregate_rating.as_slice()
1063	}
1064	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
1065		std::mem::take(&mut self.r#aggregate_rating)
1066	}
1067	fn get_asin(&self) -> &[AsinProperty] {
1068		self.r#asin.as_slice()
1069	}
1070	fn take_asin(&mut self) -> Vec<AsinProperty> {
1071		std::mem::take(&mut self.r#asin)
1072	}
1073	fn get_audience(&self) -> &[AudienceProperty] {
1074		self.r#audience.as_slice()
1075	}
1076	fn take_audience(&mut self) -> Vec<AudienceProperty> {
1077		std::mem::take(&mut self.r#audience)
1078	}
1079	fn get_award(&self) -> &[AwardProperty] {
1080		self.r#award.as_slice()
1081	}
1082	fn take_award(&mut self) -> Vec<AwardProperty> {
1083		std::mem::take(&mut self.r#award)
1084	}
1085	fn get_awards(&self) -> &[AwardsProperty] {
1086		self.r#awards.as_slice()
1087	}
1088	fn take_awards(&mut self) -> Vec<AwardsProperty> {
1089		std::mem::take(&mut self.r#awards)
1090	}
1091	fn get_brand(&self) -> &[BrandProperty] {
1092		self.r#brand.as_slice()
1093	}
1094	fn take_brand(&mut self) -> Vec<BrandProperty> {
1095		std::mem::take(&mut self.r#brand)
1096	}
1097	fn get_category(&self) -> &[CategoryProperty] {
1098		self.r#category.as_slice()
1099	}
1100	fn take_category(&mut self) -> Vec<CategoryProperty> {
1101		std::mem::take(&mut self.r#category)
1102	}
1103	fn get_color(&self) -> &[ColorProperty] {
1104		self.r#color.as_slice()
1105	}
1106	fn take_color(&mut self) -> Vec<ColorProperty> {
1107		std::mem::take(&mut self.r#color)
1108	}
1109	fn get_country_of_assembly(&self) -> &[CountryOfAssemblyProperty] {
1110		self.r#country_of_assembly.as_slice()
1111	}
1112	fn take_country_of_assembly(&mut self) -> Vec<CountryOfAssemblyProperty> {
1113		std::mem::take(&mut self.r#country_of_assembly)
1114	}
1115	fn get_country_of_last_processing(&self) -> &[CountryOfLastProcessingProperty] {
1116		self.r#country_of_last_processing.as_slice()
1117	}
1118	fn take_country_of_last_processing(&mut self) -> Vec<CountryOfLastProcessingProperty> {
1119		std::mem::take(&mut self.r#country_of_last_processing)
1120	}
1121	fn get_country_of_origin(&self) -> &[CountryOfOriginProperty] {
1122		self.r#country_of_origin.as_slice()
1123	}
1124	fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty> {
1125		std::mem::take(&mut self.r#country_of_origin)
1126	}
1127	fn get_depth(&self) -> &[DepthProperty] {
1128		self.r#depth.as_slice()
1129	}
1130	fn take_depth(&mut self) -> Vec<DepthProperty> {
1131		std::mem::take(&mut self.r#depth)
1132	}
1133	fn get_funding(&self) -> &[FundingProperty] {
1134		self.r#funding.as_slice()
1135	}
1136	fn take_funding(&mut self) -> Vec<FundingProperty> {
1137		std::mem::take(&mut self.r#funding)
1138	}
1139	fn get_gtin(&self) -> &[GtinProperty] {
1140		self.r#gtin.as_slice()
1141	}
1142	fn take_gtin(&mut self) -> Vec<GtinProperty> {
1143		std::mem::take(&mut self.r#gtin)
1144	}
1145	fn get_gtin_12(&self) -> &[Gtin12Property] {
1146		self.r#gtin_12.as_slice()
1147	}
1148	fn take_gtin_12(&mut self) -> Vec<Gtin12Property> {
1149		std::mem::take(&mut self.r#gtin_12)
1150	}
1151	fn get_gtin_13(&self) -> &[Gtin13Property] {
1152		self.r#gtin_13.as_slice()
1153	}
1154	fn take_gtin_13(&mut self) -> Vec<Gtin13Property> {
1155		std::mem::take(&mut self.r#gtin_13)
1156	}
1157	fn get_gtin_14(&self) -> &[Gtin14Property] {
1158		self.r#gtin_14.as_slice()
1159	}
1160	fn take_gtin_14(&mut self) -> Vec<Gtin14Property> {
1161		std::mem::take(&mut self.r#gtin_14)
1162	}
1163	fn get_gtin_8(&self) -> &[Gtin8Property] {
1164		self.r#gtin_8.as_slice()
1165	}
1166	fn take_gtin_8(&mut self) -> Vec<Gtin8Property> {
1167		std::mem::take(&mut self.r#gtin_8)
1168	}
1169	fn get_has_adult_consideration(&self) -> &[HasAdultConsiderationProperty] {
1170		self.r#has_adult_consideration.as_slice()
1171	}
1172	fn take_has_adult_consideration(&mut self) -> Vec<HasAdultConsiderationProperty> {
1173		std::mem::take(&mut self.r#has_adult_consideration)
1174	}
1175	fn get_has_energy_consumption_details(&self) -> &[HasEnergyConsumptionDetailsProperty] {
1176		self.r#has_energy_consumption_details.as_slice()
1177	}
1178	fn take_has_energy_consumption_details(&mut self) -> Vec<HasEnergyConsumptionDetailsProperty> {
1179		std::mem::take(&mut self.r#has_energy_consumption_details)
1180	}
1181	fn get_has_measurement(&self) -> &[HasMeasurementProperty] {
1182		self.r#has_measurement.as_slice()
1183	}
1184	fn take_has_measurement(&mut self) -> Vec<HasMeasurementProperty> {
1185		std::mem::take(&mut self.r#has_measurement)
1186	}
1187	fn get_has_merchant_return_policy(&self) -> &[HasMerchantReturnPolicyProperty] {
1188		self.r#has_merchant_return_policy.as_slice()
1189	}
1190	fn take_has_merchant_return_policy(&mut self) -> Vec<HasMerchantReturnPolicyProperty> {
1191		std::mem::take(&mut self.r#has_merchant_return_policy)
1192	}
1193	fn get_has_product_return_policy(&self) -> &[HasProductReturnPolicyProperty] {
1194		self.r#has_product_return_policy.as_slice()
1195	}
1196	fn take_has_product_return_policy(&mut self) -> Vec<HasProductReturnPolicyProperty> {
1197		std::mem::take(&mut self.r#has_product_return_policy)
1198	}
1199	fn get_height(&self) -> &[HeightProperty] {
1200		self.r#height.as_slice()
1201	}
1202	fn take_height(&mut self) -> Vec<HeightProperty> {
1203		std::mem::take(&mut self.r#height)
1204	}
1205	fn get_in_product_group_with_id(&self) -> &[InProductGroupWithIdProperty] {
1206		self.r#in_product_group_with_id.as_slice()
1207	}
1208	fn take_in_product_group_with_id(&mut self) -> Vec<InProductGroupWithIdProperty> {
1209		std::mem::take(&mut self.r#in_product_group_with_id)
1210	}
1211	fn get_is_accessory_or_spare_part_for(&self) -> &[IsAccessoryOrSparePartForProperty] {
1212		self.r#is_accessory_or_spare_part_for.as_slice()
1213	}
1214	fn take_is_accessory_or_spare_part_for(&mut self) -> Vec<IsAccessoryOrSparePartForProperty> {
1215		std::mem::take(&mut self.r#is_accessory_or_spare_part_for)
1216	}
1217	fn get_is_consumable_for(&self) -> &[IsConsumableForProperty] {
1218		self.r#is_consumable_for.as_slice()
1219	}
1220	fn take_is_consumable_for(&mut self) -> Vec<IsConsumableForProperty> {
1221		std::mem::take(&mut self.r#is_consumable_for)
1222	}
1223	fn get_is_family_friendly(&self) -> &[IsFamilyFriendlyProperty] {
1224		self.r#is_family_friendly.as_slice()
1225	}
1226	fn take_is_family_friendly(&mut self) -> Vec<IsFamilyFriendlyProperty> {
1227		std::mem::take(&mut self.r#is_family_friendly)
1228	}
1229	fn get_is_related_to(&self) -> &[IsRelatedToProperty] {
1230		self.r#is_related_to.as_slice()
1231	}
1232	fn take_is_related_to(&mut self) -> Vec<IsRelatedToProperty> {
1233		std::mem::take(&mut self.r#is_related_to)
1234	}
1235	fn get_is_similar_to(&self) -> &[IsSimilarToProperty] {
1236		self.r#is_similar_to.as_slice()
1237	}
1238	fn take_is_similar_to(&mut self) -> Vec<IsSimilarToProperty> {
1239		std::mem::take(&mut self.r#is_similar_to)
1240	}
1241	fn get_is_variant_of(&self) -> &[IsVariantOfProperty] {
1242		self.r#is_variant_of.as_slice()
1243	}
1244	fn take_is_variant_of(&mut self) -> Vec<IsVariantOfProperty> {
1245		std::mem::take(&mut self.r#is_variant_of)
1246	}
1247	fn get_item_condition(&self) -> &[ItemConditionProperty] {
1248		self.r#item_condition.as_slice()
1249	}
1250	fn take_item_condition(&mut self) -> Vec<ItemConditionProperty> {
1251		std::mem::take(&mut self.r#item_condition)
1252	}
1253	fn get_keywords(&self) -> &[KeywordsProperty] {
1254		self.r#keywords.as_slice()
1255	}
1256	fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
1257		std::mem::take(&mut self.r#keywords)
1258	}
1259	fn get_logo(&self) -> &[LogoProperty] {
1260		self.r#logo.as_slice()
1261	}
1262	fn take_logo(&mut self) -> Vec<LogoProperty> {
1263		std::mem::take(&mut self.r#logo)
1264	}
1265	fn get_manufacturer(&self) -> &[ManufacturerProperty] {
1266		self.r#manufacturer.as_slice()
1267	}
1268	fn take_manufacturer(&mut self) -> Vec<ManufacturerProperty> {
1269		std::mem::take(&mut self.r#manufacturer)
1270	}
1271	fn get_material(&self) -> &[MaterialProperty] {
1272		self.r#material.as_slice()
1273	}
1274	fn take_material(&mut self) -> Vec<MaterialProperty> {
1275		std::mem::take(&mut self.r#material)
1276	}
1277	fn get_mobile_url(&self) -> &[MobileUrlProperty] {
1278		self.r#mobile_url.as_slice()
1279	}
1280	fn take_mobile_url(&mut self) -> Vec<MobileUrlProperty> {
1281		std::mem::take(&mut self.r#mobile_url)
1282	}
1283	fn get_model(&self) -> &[ModelProperty] {
1284		self.r#model.as_slice()
1285	}
1286	fn take_model(&mut self) -> Vec<ModelProperty> {
1287		std::mem::take(&mut self.r#model)
1288	}
1289	fn get_mpn(&self) -> &[MpnProperty] {
1290		self.r#mpn.as_slice()
1291	}
1292	fn take_mpn(&mut self) -> Vec<MpnProperty> {
1293		std::mem::take(&mut self.r#mpn)
1294	}
1295	fn get_negative_notes(&self) -> &[NegativeNotesProperty] {
1296		self.r#negative_notes.as_slice()
1297	}
1298	fn take_negative_notes(&mut self) -> Vec<NegativeNotesProperty> {
1299		std::mem::take(&mut self.r#negative_notes)
1300	}
1301	fn get_nsn(&self) -> &[NsnProperty] {
1302		self.r#nsn.as_slice()
1303	}
1304	fn take_nsn(&mut self) -> Vec<NsnProperty> {
1305		std::mem::take(&mut self.r#nsn)
1306	}
1307	fn get_offers(&self) -> &[OffersProperty] {
1308		self.r#offers.as_slice()
1309	}
1310	fn take_offers(&mut self) -> Vec<OffersProperty> {
1311		std::mem::take(&mut self.r#offers)
1312	}
1313	fn get_pattern(&self) -> &[PatternProperty] {
1314		self.r#pattern.as_slice()
1315	}
1316	fn take_pattern(&mut self) -> Vec<PatternProperty> {
1317		std::mem::take(&mut self.r#pattern)
1318	}
1319	fn get_positive_notes(&self) -> &[PositiveNotesProperty] {
1320		self.r#positive_notes.as_slice()
1321	}
1322	fn take_positive_notes(&mut self) -> Vec<PositiveNotesProperty> {
1323		std::mem::take(&mut self.r#positive_notes)
1324	}
1325	fn get_product_id(&self) -> &[ProductIdProperty] {
1326		self.r#product_id.as_slice()
1327	}
1328	fn take_product_id(&mut self) -> Vec<ProductIdProperty> {
1329		std::mem::take(&mut self.r#product_id)
1330	}
1331	fn get_production_date(&self) -> &[ProductionDateProperty] {
1332		self.r#production_date.as_slice()
1333	}
1334	fn take_production_date(&mut self) -> Vec<ProductionDateProperty> {
1335		std::mem::take(&mut self.r#production_date)
1336	}
1337	fn get_purchase_date(&self) -> &[PurchaseDateProperty] {
1338		self.r#purchase_date.as_slice()
1339	}
1340	fn take_purchase_date(&mut self) -> Vec<PurchaseDateProperty> {
1341		std::mem::take(&mut self.r#purchase_date)
1342	}
1343	fn get_release_date(&self) -> &[ReleaseDateProperty] {
1344		self.r#release_date.as_slice()
1345	}
1346	fn take_release_date(&mut self) -> Vec<ReleaseDateProperty> {
1347		std::mem::take(&mut self.r#release_date)
1348	}
1349	fn get_review(&self) -> &[ReviewProperty] {
1350		self.r#review.as_slice()
1351	}
1352	fn take_review(&mut self) -> Vec<ReviewProperty> {
1353		std::mem::take(&mut self.r#review)
1354	}
1355	fn get_reviews(&self) -> &[ReviewsProperty] {
1356		self.r#reviews.as_slice()
1357	}
1358	fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
1359		std::mem::take(&mut self.r#reviews)
1360	}
1361	fn get_size(&self) -> &[SizeProperty] {
1362		self.r#size.as_slice()
1363	}
1364	fn take_size(&mut self) -> Vec<SizeProperty> {
1365		std::mem::take(&mut self.r#size)
1366	}
1367	fn get_sku(&self) -> &[SkuProperty] {
1368		self.r#sku.as_slice()
1369	}
1370	fn take_sku(&mut self) -> Vec<SkuProperty> {
1371		std::mem::take(&mut self.r#sku)
1372	}
1373	fn get_slogan(&self) -> &[SloganProperty] {
1374		self.r#slogan.as_slice()
1375	}
1376	fn take_slogan(&mut self) -> Vec<SloganProperty> {
1377		std::mem::take(&mut self.r#slogan)
1378	}
1379	fn get_weight(&self) -> &[WeightProperty] {
1380		self.r#weight.as_slice()
1381	}
1382	fn take_weight(&mut self) -> Vec<WeightProperty> {
1383		std::mem::take(&mut self.r#weight)
1384	}
1385	fn get_width(&self) -> &[WidthProperty] {
1386		self.r#width.as_slice()
1387	}
1388	fn take_width(&mut self) -> Vec<WidthProperty> {
1389		std::mem::take(&mut self.r#width)
1390	}
1391}
1392impl ThingTrait for ProductCollection {
1393	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
1394		self.r#additional_type.as_slice()
1395	}
1396	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
1397		std::mem::take(&mut self.r#additional_type)
1398	}
1399	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
1400		self.r#alternate_name.as_slice()
1401	}
1402	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
1403		std::mem::take(&mut self.r#alternate_name)
1404	}
1405	fn get_description(&self) -> &[DescriptionProperty] {
1406		self.r#description.as_slice()
1407	}
1408	fn take_description(&mut self) -> Vec<DescriptionProperty> {
1409		std::mem::take(&mut self.r#description)
1410	}
1411	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
1412		self.r#disambiguating_description.as_slice()
1413	}
1414	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
1415		std::mem::take(&mut self.r#disambiguating_description)
1416	}
1417	fn get_identifier(&self) -> &[IdentifierProperty] {
1418		self.r#identifier.as_slice()
1419	}
1420	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
1421		std::mem::take(&mut self.r#identifier)
1422	}
1423	fn get_image(&self) -> &[ImageProperty] {
1424		self.r#image.as_slice()
1425	}
1426	fn take_image(&mut self) -> Vec<ImageProperty> {
1427		std::mem::take(&mut self.r#image)
1428	}
1429	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
1430		self.r#main_entity_of_page.as_slice()
1431	}
1432	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
1433		std::mem::take(&mut self.r#main_entity_of_page)
1434	}
1435	fn get_name(&self) -> &[NameProperty] {
1436		self.r#name.as_slice()
1437	}
1438	fn take_name(&mut self) -> Vec<NameProperty> {
1439		std::mem::take(&mut self.r#name)
1440	}
1441	fn get_potential_action(&self) -> &[PotentialActionProperty] {
1442		self.r#potential_action.as_slice()
1443	}
1444	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
1445		std::mem::take(&mut self.r#potential_action)
1446	}
1447	fn get_same_as(&self) -> &[SameAsProperty] {
1448		self.r#same_as.as_slice()
1449	}
1450	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
1451		std::mem::take(&mut self.r#same_as)
1452	}
1453	fn get_subject_of(&self) -> &[SubjectOfProperty] {
1454		self.r#subject_of.as_slice()
1455	}
1456	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
1457		std::mem::take(&mut self.r#subject_of)
1458	}
1459	fn get_url(&self) -> &[UrlProperty] {
1460		self.r#url.as_slice()
1461	}
1462	fn take_url(&mut self) -> Vec<UrlProperty> {
1463		std::mem::take(&mut self.r#url)
1464	}
1465}
1466#[cfg(feature = "serde")]
1467mod serde {
1468	use std::{fmt, fmt::Formatter};
1469
1470	use ::serde::{
1471		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
1472	};
1473
1474	use super::*;
1475	impl Serialize for ProductCollection {
1476		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1477		where
1478			S: Serializer,
1479		{
1480			let len: usize = [
1481				!Vec::is_empty(&self.r#includes_object) as usize,
1482				!Vec::is_empty(&self.r#collection_size) as usize,
1483				!Vec::is_empty(&self.r#about) as usize,
1484				!Vec::is_empty(&self.r#abstract) as usize,
1485				!Vec::is_empty(&self.r#access_mode) as usize,
1486				!Vec::is_empty(&self.r#access_mode_sufficient) as usize,
1487				!Vec::is_empty(&self.r#accessibility_api) as usize,
1488				!Vec::is_empty(&self.r#accessibility_control) as usize,
1489				!Vec::is_empty(&self.r#accessibility_feature) as usize,
1490				!Vec::is_empty(&self.r#accessibility_hazard) as usize,
1491				!Vec::is_empty(&self.r#accessibility_summary) as usize,
1492				!Vec::is_empty(&self.r#accountable_person) as usize,
1493				!Vec::is_empty(&self.r#acquire_license_page) as usize,
1494				!Vec::is_empty(&self.r#aggregate_rating) as usize,
1495				!Vec::is_empty(&self.r#alternative_headline) as usize,
1496				!Vec::is_empty(&self.r#archived_at) as usize,
1497				!Vec::is_empty(&self.r#assesses) as usize,
1498				!Vec::is_empty(&self.r#associated_media) as usize,
1499				!Vec::is_empty(&self.r#audience) as usize,
1500				!Vec::is_empty(&self.r#audio) as usize,
1501				!Vec::is_empty(&self.r#author) as usize,
1502				!Vec::is_empty(&self.r#award) as usize,
1503				!Vec::is_empty(&self.r#awards) as usize,
1504				!Vec::is_empty(&self.r#character) as usize,
1505				!Vec::is_empty(&self.r#citation) as usize,
1506				!Vec::is_empty(&self.r#comment) as usize,
1507				!Vec::is_empty(&self.r#comment_count) as usize,
1508				!Vec::is_empty(&self.r#conditions_of_access) as usize,
1509				!Vec::is_empty(&self.r#content_location) as usize,
1510				!Vec::is_empty(&self.r#content_rating) as usize,
1511				!Vec::is_empty(&self.r#content_reference_time) as usize,
1512				!Vec::is_empty(&self.r#contributor) as usize,
1513				!Vec::is_empty(&self.r#copyright_holder) as usize,
1514				!Vec::is_empty(&self.r#copyright_notice) as usize,
1515				!Vec::is_empty(&self.r#copyright_year) as usize,
1516				!Vec::is_empty(&self.r#correction) as usize,
1517				!Vec::is_empty(&self.r#country_of_origin) as usize,
1518				!Vec::is_empty(&self.r#creative_work_status) as usize,
1519				!Vec::is_empty(&self.r#creator) as usize,
1520				!Vec::is_empty(&self.r#credit_text) as usize,
1521				!Vec::is_empty(&self.r#date_created) as usize,
1522				!Vec::is_empty(&self.r#date_modified) as usize,
1523				!Vec::is_empty(&self.r#date_published) as usize,
1524				!Vec::is_empty(&self.r#discussion_url) as usize,
1525				!Vec::is_empty(&self.r#edit_eidr) as usize,
1526				!Vec::is_empty(&self.r#editor) as usize,
1527				!Vec::is_empty(&self.r#educational_alignment) as usize,
1528				!Vec::is_empty(&self.r#educational_level) as usize,
1529				!Vec::is_empty(&self.r#educational_use) as usize,
1530				!Vec::is_empty(&self.r#encoding) as usize,
1531				!Vec::is_empty(&self.r#encoding_format) as usize,
1532				!Vec::is_empty(&self.r#encodings) as usize,
1533				!Vec::is_empty(&self.r#example_of_work) as usize,
1534				!Vec::is_empty(&self.r#expires) as usize,
1535				!Vec::is_empty(&self.r#file_format) as usize,
1536				!Vec::is_empty(&self.r#funder) as usize,
1537				!Vec::is_empty(&self.r#funding) as usize,
1538				!Vec::is_empty(&self.r#genre) as usize,
1539				!Vec::is_empty(&self.r#has_part) as usize,
1540				!Vec::is_empty(&self.r#headline) as usize,
1541				!Vec::is_empty(&self.r#in_language) as usize,
1542				!Vec::is_empty(&self.r#interaction_statistic) as usize,
1543				!Vec::is_empty(&self.r#interactivity_type) as usize,
1544				!Vec::is_empty(&self.r#interpreted_as_claim) as usize,
1545				!Vec::is_empty(&self.r#is_accessible_for_free) as usize,
1546				!Vec::is_empty(&self.r#is_based_on) as usize,
1547				!Vec::is_empty(&self.r#is_based_on_url) as usize,
1548				!Vec::is_empty(&self.r#is_family_friendly) as usize,
1549				!Vec::is_empty(&self.r#is_part_of) as usize,
1550				!Vec::is_empty(&self.r#keywords) as usize,
1551				!Vec::is_empty(&self.r#learning_resource_type) as usize,
1552				!Vec::is_empty(&self.r#license) as usize,
1553				!Vec::is_empty(&self.r#location_created) as usize,
1554				!Vec::is_empty(&self.r#main_entity) as usize,
1555				!Vec::is_empty(&self.r#maintainer) as usize,
1556				!Vec::is_empty(&self.r#material) as usize,
1557				!Vec::is_empty(&self.r#material_extent) as usize,
1558				!Vec::is_empty(&self.r#mentions) as usize,
1559				!Vec::is_empty(&self.r#offers) as usize,
1560				!Vec::is_empty(&self.r#pattern) as usize,
1561				!Vec::is_empty(&self.r#position) as usize,
1562				!Vec::is_empty(&self.r#producer) as usize,
1563				!Vec::is_empty(&self.r#provider) as usize,
1564				!Vec::is_empty(&self.r#publication) as usize,
1565				!Vec::is_empty(&self.r#publisher) as usize,
1566				!Vec::is_empty(&self.r#publisher_imprint) as usize,
1567				!Vec::is_empty(&self.r#publishing_principles) as usize,
1568				!Vec::is_empty(&self.r#recorded_at) as usize,
1569				!Vec::is_empty(&self.r#released_event) as usize,
1570				!Vec::is_empty(&self.r#review) as usize,
1571				!Vec::is_empty(&self.r#reviews) as usize,
1572				!Vec::is_empty(&self.r#schema_version) as usize,
1573				!Vec::is_empty(&self.r#sd_date_published) as usize,
1574				!Vec::is_empty(&self.r#sd_license) as usize,
1575				!Vec::is_empty(&self.r#sd_publisher) as usize,
1576				!Vec::is_empty(&self.r#size) as usize,
1577				!Vec::is_empty(&self.r#source_organization) as usize,
1578				!Vec::is_empty(&self.r#spatial) as usize,
1579				!Vec::is_empty(&self.r#spatial_coverage) as usize,
1580				!Vec::is_empty(&self.r#sponsor) as usize,
1581				!Vec::is_empty(&self.r#teaches) as usize,
1582				!Vec::is_empty(&self.r#temporal) as usize,
1583				!Vec::is_empty(&self.r#temporal_coverage) as usize,
1584				!Vec::is_empty(&self.r#text) as usize,
1585				!Vec::is_empty(&self.r#thumbnail) as usize,
1586				!Vec::is_empty(&self.r#thumbnail_url) as usize,
1587				!Vec::is_empty(&self.r#time_required) as usize,
1588				!Vec::is_empty(&self.r#translation_of_work) as usize,
1589				!Vec::is_empty(&self.r#translator) as usize,
1590				!Vec::is_empty(&self.r#typical_age_range) as usize,
1591				!Vec::is_empty(&self.r#usage_info) as usize,
1592				!Vec::is_empty(&self.r#version) as usize,
1593				!Vec::is_empty(&self.r#video) as usize,
1594				!Vec::is_empty(&self.r#work_example) as usize,
1595				!Vec::is_empty(&self.r#work_translation) as usize,
1596				!Vec::is_empty(&self.r#additional_property) as usize,
1597				!Vec::is_empty(&self.r#asin) as usize,
1598				!Vec::is_empty(&self.r#brand) as usize,
1599				!Vec::is_empty(&self.r#category) as usize,
1600				!Vec::is_empty(&self.r#color) as usize,
1601				!Vec::is_empty(&self.r#country_of_assembly) as usize,
1602				!Vec::is_empty(&self.r#country_of_last_processing) as usize,
1603				!Vec::is_empty(&self.r#depth) as usize,
1604				!Vec::is_empty(&self.r#gtin) as usize,
1605				!Vec::is_empty(&self.r#gtin_12) as usize,
1606				!Vec::is_empty(&self.r#gtin_13) as usize,
1607				!Vec::is_empty(&self.r#gtin_14) as usize,
1608				!Vec::is_empty(&self.r#gtin_8) as usize,
1609				!Vec::is_empty(&self.r#has_adult_consideration) as usize,
1610				!Vec::is_empty(&self.r#has_energy_consumption_details) as usize,
1611				!Vec::is_empty(&self.r#has_measurement) as usize,
1612				!Vec::is_empty(&self.r#has_merchant_return_policy) as usize,
1613				!Vec::is_empty(&self.r#has_product_return_policy) as usize,
1614				!Vec::is_empty(&self.r#height) as usize,
1615				!Vec::is_empty(&self.r#in_product_group_with_id) as usize,
1616				!Vec::is_empty(&self.r#is_accessory_or_spare_part_for) as usize,
1617				!Vec::is_empty(&self.r#is_consumable_for) as usize,
1618				!Vec::is_empty(&self.r#is_related_to) as usize,
1619				!Vec::is_empty(&self.r#is_similar_to) as usize,
1620				!Vec::is_empty(&self.r#is_variant_of) as usize,
1621				!Vec::is_empty(&self.r#item_condition) as usize,
1622				!Vec::is_empty(&self.r#logo) as usize,
1623				!Vec::is_empty(&self.r#manufacturer) as usize,
1624				!Vec::is_empty(&self.r#mobile_url) as usize,
1625				!Vec::is_empty(&self.r#model) as usize,
1626				!Vec::is_empty(&self.r#mpn) as usize,
1627				!Vec::is_empty(&self.r#negative_notes) as usize,
1628				!Vec::is_empty(&self.r#nsn) as usize,
1629				!Vec::is_empty(&self.r#positive_notes) as usize,
1630				!Vec::is_empty(&self.r#product_id) as usize,
1631				!Vec::is_empty(&self.r#production_date) as usize,
1632				!Vec::is_empty(&self.r#purchase_date) as usize,
1633				!Vec::is_empty(&self.r#release_date) as usize,
1634				!Vec::is_empty(&self.r#sku) as usize,
1635				!Vec::is_empty(&self.r#slogan) as usize,
1636				!Vec::is_empty(&self.r#weight) as usize,
1637				!Vec::is_empty(&self.r#width) as usize,
1638				!Vec::is_empty(&self.r#additional_type) as usize,
1639				!Vec::is_empty(&self.r#alternate_name) as usize,
1640				!Vec::is_empty(&self.r#description) as usize,
1641				!Vec::is_empty(&self.r#disambiguating_description) as usize,
1642				!Vec::is_empty(&self.r#identifier) as usize,
1643				!Vec::is_empty(&self.r#image) as usize,
1644				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
1645				!Vec::is_empty(&self.r#name) as usize,
1646				!Vec::is_empty(&self.r#potential_action) as usize,
1647				!Vec::is_empty(&self.r#same_as) as usize,
1648				!Vec::is_empty(&self.r#subject_of) as usize,
1649				!Vec::is_empty(&self.r#url) as usize,
1650			]
1651			.iter()
1652			.sum();
1653			let mut serialize_struct =
1654				Serializer::serialize_struct(serializer, "ProductCollection", len)?;
1655			if !Vec::is_empty(&self.r#includes_object) {
1656				serialize_struct.serialize_field("includesObject", {
1657					struct SerializeWith<'a>(&'a Vec<IncludesObjectProperty>);
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#includes_object)
1669				})?;
1670			} else {
1671				serialize_struct.skip_field("includesObject")?;
1672			}
1673			if !Vec::is_empty(&self.r#collection_size) {
1674				serialize_struct.serialize_field("collectionSize", {
1675					struct SerializeWith<'a>(&'a Vec<CollectionSizeProperty>);
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#collection_size)
1687				})?;
1688			} else {
1689				serialize_struct.skip_field("collectionSize")?;
1690			}
1691			if !Vec::is_empty(&self.r#about) {
1692				serialize_struct.serialize_field("about", {
1693					struct SerializeWith<'a>(&'a Vec<AboutProperty>);
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#about)
1705				})?;
1706			} else {
1707				serialize_struct.skip_field("about")?;
1708			}
1709			if !Vec::is_empty(&self.r#abstract) {
1710				serialize_struct.serialize_field("abstract", {
1711					struct SerializeWith<'a>(&'a Vec<AbstractProperty>);
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#abstract)
1723				})?;
1724			} else {
1725				serialize_struct.skip_field("abstract")?;
1726			}
1727			if !Vec::is_empty(&self.r#access_mode) {
1728				serialize_struct.serialize_field("accessMode", {
1729					struct SerializeWith<'a>(&'a Vec<AccessModeProperty>);
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#access_mode)
1741				})?;
1742			} else {
1743				serialize_struct.skip_field("accessMode")?;
1744			}
1745			if !Vec::is_empty(&self.r#access_mode_sufficient) {
1746				serialize_struct.serialize_field("accessModeSufficient", {
1747					struct SerializeWith<'a>(&'a Vec<AccessModeSufficientProperty>);
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#access_mode_sufficient)
1759				})?;
1760			} else {
1761				serialize_struct.skip_field("accessModeSufficient")?;
1762			}
1763			if !Vec::is_empty(&self.r#accessibility_api) {
1764				serialize_struct.serialize_field("accessibilityAPI", {
1765					struct SerializeWith<'a>(&'a Vec<AccessibilityApiProperty>);
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#accessibility_api)
1777				})?;
1778			} else {
1779				serialize_struct.skip_field("accessibilityAPI")?;
1780			}
1781			if !Vec::is_empty(&self.r#accessibility_control) {
1782				serialize_struct.serialize_field("accessibilityControl", {
1783					struct SerializeWith<'a>(&'a Vec<AccessibilityControlProperty>);
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#accessibility_control)
1795				})?;
1796			} else {
1797				serialize_struct.skip_field("accessibilityControl")?;
1798			}
1799			if !Vec::is_empty(&self.r#accessibility_feature) {
1800				serialize_struct.serialize_field("accessibilityFeature", {
1801					struct SerializeWith<'a>(&'a Vec<AccessibilityFeatureProperty>);
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#accessibility_feature)
1813				})?;
1814			} else {
1815				serialize_struct.skip_field("accessibilityFeature")?;
1816			}
1817			if !Vec::is_empty(&self.r#accessibility_hazard) {
1818				serialize_struct.serialize_field("accessibilityHazard", {
1819					struct SerializeWith<'a>(&'a Vec<AccessibilityHazardProperty>);
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#accessibility_hazard)
1831				})?;
1832			} else {
1833				serialize_struct.skip_field("accessibilityHazard")?;
1834			}
1835			if !Vec::is_empty(&self.r#accessibility_summary) {
1836				serialize_struct.serialize_field("accessibilitySummary", {
1837					struct SerializeWith<'a>(&'a Vec<AccessibilitySummaryProperty>);
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#accessibility_summary)
1849				})?;
1850			} else {
1851				serialize_struct.skip_field("accessibilitySummary")?;
1852			}
1853			if !Vec::is_empty(&self.r#accountable_person) {
1854				serialize_struct.serialize_field("accountablePerson", {
1855					struct SerializeWith<'a>(&'a Vec<AccountablePersonProperty>);
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#accountable_person)
1867				})?;
1868			} else {
1869				serialize_struct.skip_field("accountablePerson")?;
1870			}
1871			if !Vec::is_empty(&self.r#acquire_license_page) {
1872				serialize_struct.serialize_field("acquireLicensePage", {
1873					struct SerializeWith<'a>(&'a Vec<AcquireLicensePageProperty>);
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#acquire_license_page)
1885				})?;
1886			} else {
1887				serialize_struct.skip_field("acquireLicensePage")?;
1888			}
1889			if !Vec::is_empty(&self.r#aggregate_rating) {
1890				serialize_struct.serialize_field("aggregateRating", {
1891					struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
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#aggregate_rating)
1903				})?;
1904			} else {
1905				serialize_struct.skip_field("aggregateRating")?;
1906			}
1907			if !Vec::is_empty(&self.r#alternative_headline) {
1908				serialize_struct.serialize_field("alternativeHeadline", {
1909					struct SerializeWith<'a>(&'a Vec<AlternativeHeadlineProperty>);
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#alternative_headline)
1921				})?;
1922			} else {
1923				serialize_struct.skip_field("alternativeHeadline")?;
1924			}
1925			if !Vec::is_empty(&self.r#archived_at) {
1926				serialize_struct.serialize_field("archivedAt", {
1927					struct SerializeWith<'a>(&'a Vec<ArchivedAtProperty>);
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#archived_at)
1939				})?;
1940			} else {
1941				serialize_struct.skip_field("archivedAt")?;
1942			}
1943			if !Vec::is_empty(&self.r#assesses) {
1944				serialize_struct.serialize_field("assesses", {
1945					struct SerializeWith<'a>(&'a Vec<AssessesProperty>);
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#assesses)
1957				})?;
1958			} else {
1959				serialize_struct.skip_field("assesses")?;
1960			}
1961			if !Vec::is_empty(&self.r#associated_media) {
1962				serialize_struct.serialize_field("associatedMedia", {
1963					struct SerializeWith<'a>(&'a Vec<AssociatedMediaProperty>);
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#associated_media)
1975				})?;
1976			} else {
1977				serialize_struct.skip_field("associatedMedia")?;
1978			}
1979			if !Vec::is_empty(&self.r#audience) {
1980				serialize_struct.serialize_field("audience", {
1981					struct SerializeWith<'a>(&'a Vec<AudienceProperty>);
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#audience)
1993				})?;
1994			} else {
1995				serialize_struct.skip_field("audience")?;
1996			}
1997			if !Vec::is_empty(&self.r#audio) {
1998				serialize_struct.serialize_field("audio", {
1999					struct SerializeWith<'a>(&'a Vec<AudioProperty>);
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#audio)
2011				})?;
2012			} else {
2013				serialize_struct.skip_field("audio")?;
2014			}
2015			if !Vec::is_empty(&self.r#author) {
2016				serialize_struct.serialize_field("author", {
2017					struct SerializeWith<'a>(&'a Vec<AuthorProperty>);
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#author)
2029				})?;
2030			} else {
2031				serialize_struct.skip_field("author")?;
2032			}
2033			if !Vec::is_empty(&self.r#award) {
2034				serialize_struct.serialize_field("award", {
2035					struct SerializeWith<'a>(&'a Vec<AwardProperty>);
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#award)
2047				})?;
2048			} else {
2049				serialize_struct.skip_field("award")?;
2050			}
2051			if !Vec::is_empty(&self.r#awards) {
2052				serialize_struct.serialize_field("awards", {
2053					struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
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#awards)
2065				})?;
2066			} else {
2067				serialize_struct.skip_field("awards")?;
2068			}
2069			if !Vec::is_empty(&self.r#character) {
2070				serialize_struct.serialize_field("character", {
2071					struct SerializeWith<'a>(&'a Vec<CharacterProperty>);
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#character)
2083				})?;
2084			} else {
2085				serialize_struct.skip_field("character")?;
2086			}
2087			if !Vec::is_empty(&self.r#citation) {
2088				serialize_struct.serialize_field("citation", {
2089					struct SerializeWith<'a>(&'a Vec<CitationProperty>);
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#citation)
2101				})?;
2102			} else {
2103				serialize_struct.skip_field("citation")?;
2104			}
2105			if !Vec::is_empty(&self.r#comment) {
2106				serialize_struct.serialize_field("comment", {
2107					struct SerializeWith<'a>(&'a Vec<CommentProperty>);
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#comment)
2119				})?;
2120			} else {
2121				serialize_struct.skip_field("comment")?;
2122			}
2123			if !Vec::is_empty(&self.r#comment_count) {
2124				serialize_struct.serialize_field("commentCount", {
2125					struct SerializeWith<'a>(&'a Vec<CommentCountProperty>);
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#comment_count)
2137				})?;
2138			} else {
2139				serialize_struct.skip_field("commentCount")?;
2140			}
2141			if !Vec::is_empty(&self.r#conditions_of_access) {
2142				serialize_struct.serialize_field("conditionsOfAccess", {
2143					struct SerializeWith<'a>(&'a Vec<ConditionsOfAccessProperty>);
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#conditions_of_access)
2155				})?;
2156			} else {
2157				serialize_struct.skip_field("conditionsOfAccess")?;
2158			}
2159			if !Vec::is_empty(&self.r#content_location) {
2160				serialize_struct.serialize_field("contentLocation", {
2161					struct SerializeWith<'a>(&'a Vec<ContentLocationProperty>);
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#content_location)
2173				})?;
2174			} else {
2175				serialize_struct.skip_field("contentLocation")?;
2176			}
2177			if !Vec::is_empty(&self.r#content_rating) {
2178				serialize_struct.serialize_field("contentRating", {
2179					struct SerializeWith<'a>(&'a Vec<ContentRatingProperty>);
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#content_rating)
2191				})?;
2192			} else {
2193				serialize_struct.skip_field("contentRating")?;
2194			}
2195			if !Vec::is_empty(&self.r#content_reference_time) {
2196				serialize_struct.serialize_field("contentReferenceTime", {
2197					struct SerializeWith<'a>(&'a Vec<ContentReferenceTimeProperty>);
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#content_reference_time)
2209				})?;
2210			} else {
2211				serialize_struct.skip_field("contentReferenceTime")?;
2212			}
2213			if !Vec::is_empty(&self.r#contributor) {
2214				serialize_struct.serialize_field("contributor", {
2215					struct SerializeWith<'a>(&'a Vec<ContributorProperty>);
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#contributor)
2227				})?;
2228			} else {
2229				serialize_struct.skip_field("contributor")?;
2230			}
2231			if !Vec::is_empty(&self.r#copyright_holder) {
2232				serialize_struct.serialize_field("copyrightHolder", {
2233					struct SerializeWith<'a>(&'a Vec<CopyrightHolderProperty>);
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#copyright_holder)
2245				})?;
2246			} else {
2247				serialize_struct.skip_field("copyrightHolder")?;
2248			}
2249			if !Vec::is_empty(&self.r#copyright_notice) {
2250				serialize_struct.serialize_field("copyrightNotice", {
2251					struct SerializeWith<'a>(&'a Vec<CopyrightNoticeProperty>);
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#copyright_notice)
2263				})?;
2264			} else {
2265				serialize_struct.skip_field("copyrightNotice")?;
2266			}
2267			if !Vec::is_empty(&self.r#copyright_year) {
2268				serialize_struct.serialize_field("copyrightYear", {
2269					struct SerializeWith<'a>(&'a Vec<CopyrightYearProperty>);
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#copyright_year)
2281				})?;
2282			} else {
2283				serialize_struct.skip_field("copyrightYear")?;
2284			}
2285			if !Vec::is_empty(&self.r#correction) {
2286				serialize_struct.serialize_field("correction", {
2287					struct SerializeWith<'a>(&'a Vec<CorrectionProperty>);
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#correction)
2299				})?;
2300			} else {
2301				serialize_struct.skip_field("correction")?;
2302			}
2303			if !Vec::is_empty(&self.r#country_of_origin) {
2304				serialize_struct.serialize_field("countryOfOrigin", {
2305					struct SerializeWith<'a>(&'a Vec<CountryOfOriginProperty>);
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#country_of_origin)
2317				})?;
2318			} else {
2319				serialize_struct.skip_field("countryOfOrigin")?;
2320			}
2321			if !Vec::is_empty(&self.r#creative_work_status) {
2322				serialize_struct.serialize_field("creativeWorkStatus", {
2323					struct SerializeWith<'a>(&'a Vec<CreativeWorkStatusProperty>);
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#creative_work_status)
2335				})?;
2336			} else {
2337				serialize_struct.skip_field("creativeWorkStatus")?;
2338			}
2339			if !Vec::is_empty(&self.r#creator) {
2340				serialize_struct.serialize_field("creator", {
2341					struct SerializeWith<'a>(&'a Vec<CreatorProperty>);
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#creator)
2353				})?;
2354			} else {
2355				serialize_struct.skip_field("creator")?;
2356			}
2357			if !Vec::is_empty(&self.r#credit_text) {
2358				serialize_struct.serialize_field("creditText", {
2359					struct SerializeWith<'a>(&'a Vec<CreditTextProperty>);
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#credit_text)
2371				})?;
2372			} else {
2373				serialize_struct.skip_field("creditText")?;
2374			}
2375			if !Vec::is_empty(&self.r#date_created) {
2376				serialize_struct.serialize_field("dateCreated", {
2377					struct SerializeWith<'a>(&'a Vec<DateCreatedProperty>);
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#date_created)
2389				})?;
2390			} else {
2391				serialize_struct.skip_field("dateCreated")?;
2392			}
2393			if !Vec::is_empty(&self.r#date_modified) {
2394				serialize_struct.serialize_field("dateModified", {
2395					struct SerializeWith<'a>(&'a Vec<DateModifiedProperty>);
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#date_modified)
2407				})?;
2408			} else {
2409				serialize_struct.skip_field("dateModified")?;
2410			}
2411			if !Vec::is_empty(&self.r#date_published) {
2412				serialize_struct.serialize_field("datePublished", {
2413					struct SerializeWith<'a>(&'a Vec<DatePublishedProperty>);
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#date_published)
2425				})?;
2426			} else {
2427				serialize_struct.skip_field("datePublished")?;
2428			}
2429			if !Vec::is_empty(&self.r#discussion_url) {
2430				serialize_struct.serialize_field("discussionUrl", {
2431					struct SerializeWith<'a>(&'a Vec<DiscussionUrlProperty>);
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#discussion_url)
2443				})?;
2444			} else {
2445				serialize_struct.skip_field("discussionUrl")?;
2446			}
2447			if !Vec::is_empty(&self.r#edit_eidr) {
2448				serialize_struct.serialize_field("editEIDR", {
2449					struct SerializeWith<'a>(&'a Vec<EditEidrProperty>);
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#edit_eidr)
2461				})?;
2462			} else {
2463				serialize_struct.skip_field("editEIDR")?;
2464			}
2465			if !Vec::is_empty(&self.r#editor) {
2466				serialize_struct.serialize_field("editor", {
2467					struct SerializeWith<'a>(&'a Vec<EditorProperty>);
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#editor)
2479				})?;
2480			} else {
2481				serialize_struct.skip_field("editor")?;
2482			}
2483			if !Vec::is_empty(&self.r#educational_alignment) {
2484				serialize_struct.serialize_field("educationalAlignment", {
2485					struct SerializeWith<'a>(&'a Vec<EducationalAlignmentProperty>);
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#educational_alignment)
2497				})?;
2498			} else {
2499				serialize_struct.skip_field("educationalAlignment")?;
2500			}
2501			if !Vec::is_empty(&self.r#educational_level) {
2502				serialize_struct.serialize_field("educationalLevel", {
2503					struct SerializeWith<'a>(&'a Vec<EducationalLevelProperty>);
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#educational_level)
2515				})?;
2516			} else {
2517				serialize_struct.skip_field("educationalLevel")?;
2518			}
2519			if !Vec::is_empty(&self.r#educational_use) {
2520				serialize_struct.serialize_field("educationalUse", {
2521					struct SerializeWith<'a>(&'a Vec<EducationalUseProperty>);
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#educational_use)
2533				})?;
2534			} else {
2535				serialize_struct.skip_field("educationalUse")?;
2536			}
2537			if !Vec::is_empty(&self.r#encoding) {
2538				serialize_struct.serialize_field("encoding", {
2539					struct SerializeWith<'a>(&'a Vec<EncodingProperty>);
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#encoding)
2551				})?;
2552			} else {
2553				serialize_struct.skip_field("encoding")?;
2554			}
2555			if !Vec::is_empty(&self.r#encoding_format) {
2556				serialize_struct.serialize_field("encodingFormat", {
2557					struct SerializeWith<'a>(&'a Vec<EncodingFormatProperty>);
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#encoding_format)
2569				})?;
2570			} else {
2571				serialize_struct.skip_field("encodingFormat")?;
2572			}
2573			if !Vec::is_empty(&self.r#encodings) {
2574				serialize_struct.serialize_field("encodings", {
2575					struct SerializeWith<'a>(&'a Vec<EncodingsProperty>);
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#encodings)
2587				})?;
2588			} else {
2589				serialize_struct.skip_field("encodings")?;
2590			}
2591			if !Vec::is_empty(&self.r#example_of_work) {
2592				serialize_struct.serialize_field("exampleOfWork", {
2593					struct SerializeWith<'a>(&'a Vec<ExampleOfWorkProperty>);
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#example_of_work)
2605				})?;
2606			} else {
2607				serialize_struct.skip_field("exampleOfWork")?;
2608			}
2609			if !Vec::is_empty(&self.r#expires) {
2610				serialize_struct.serialize_field("expires", {
2611					struct SerializeWith<'a>(&'a Vec<ExpiresProperty>);
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#expires)
2623				})?;
2624			} else {
2625				serialize_struct.skip_field("expires")?;
2626			}
2627			if !Vec::is_empty(&self.r#file_format) {
2628				serialize_struct.serialize_field("fileFormat", {
2629					struct SerializeWith<'a>(&'a Vec<FileFormatProperty>);
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#file_format)
2641				})?;
2642			} else {
2643				serialize_struct.skip_field("fileFormat")?;
2644			}
2645			if !Vec::is_empty(&self.r#funder) {
2646				serialize_struct.serialize_field("funder", {
2647					struct SerializeWith<'a>(&'a Vec<FunderProperty>);
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#funder)
2659				})?;
2660			} else {
2661				serialize_struct.skip_field("funder")?;
2662			}
2663			if !Vec::is_empty(&self.r#funding) {
2664				serialize_struct.serialize_field("funding", {
2665					struct SerializeWith<'a>(&'a Vec<FundingProperty>);
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#funding)
2677				})?;
2678			} else {
2679				serialize_struct.skip_field("funding")?;
2680			}
2681			if !Vec::is_empty(&self.r#genre) {
2682				serialize_struct.serialize_field("genre", {
2683					struct SerializeWith<'a>(&'a Vec<GenreProperty>);
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#genre)
2695				})?;
2696			} else {
2697				serialize_struct.skip_field("genre")?;
2698			}
2699			if !Vec::is_empty(&self.r#has_part) {
2700				serialize_struct.serialize_field("hasPart", {
2701					struct SerializeWith<'a>(&'a Vec<HasPartProperty>);
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#has_part)
2713				})?;
2714			} else {
2715				serialize_struct.skip_field("hasPart")?;
2716			}
2717			if !Vec::is_empty(&self.r#headline) {
2718				serialize_struct.serialize_field("headline", {
2719					struct SerializeWith<'a>(&'a Vec<HeadlineProperty>);
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#headline)
2731				})?;
2732			} else {
2733				serialize_struct.skip_field("headline")?;
2734			}
2735			if !Vec::is_empty(&self.r#in_language) {
2736				serialize_struct.serialize_field("inLanguage", {
2737					struct SerializeWith<'a>(&'a Vec<InLanguageProperty>);
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#in_language)
2749				})?;
2750			} else {
2751				serialize_struct.skip_field("inLanguage")?;
2752			}
2753			if !Vec::is_empty(&self.r#interaction_statistic) {
2754				serialize_struct.serialize_field("interactionStatistic", {
2755					struct SerializeWith<'a>(&'a Vec<InteractionStatisticProperty>);
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#interaction_statistic)
2767				})?;
2768			} else {
2769				serialize_struct.skip_field("interactionStatistic")?;
2770			}
2771			if !Vec::is_empty(&self.r#interactivity_type) {
2772				serialize_struct.serialize_field("interactivityType", {
2773					struct SerializeWith<'a>(&'a Vec<InteractivityTypeProperty>);
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#interactivity_type)
2785				})?;
2786			} else {
2787				serialize_struct.skip_field("interactivityType")?;
2788			}
2789			if !Vec::is_empty(&self.r#interpreted_as_claim) {
2790				serialize_struct.serialize_field("interpretedAsClaim", {
2791					struct SerializeWith<'a>(&'a Vec<InterpretedAsClaimProperty>);
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#interpreted_as_claim)
2803				})?;
2804			} else {
2805				serialize_struct.skip_field("interpretedAsClaim")?;
2806			}
2807			if !Vec::is_empty(&self.r#is_accessible_for_free) {
2808				serialize_struct.serialize_field("isAccessibleForFree", {
2809					struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
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#is_accessible_for_free)
2821				})?;
2822			} else {
2823				serialize_struct.skip_field("isAccessibleForFree")?;
2824			}
2825			if !Vec::is_empty(&self.r#is_based_on) {
2826				serialize_struct.serialize_field("isBasedOn", {
2827					struct SerializeWith<'a>(&'a Vec<IsBasedOnProperty>);
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#is_based_on)
2839				})?;
2840			} else {
2841				serialize_struct.skip_field("isBasedOn")?;
2842			}
2843			if !Vec::is_empty(&self.r#is_based_on_url) {
2844				serialize_struct.serialize_field("isBasedOnUrl", {
2845					struct SerializeWith<'a>(&'a Vec<IsBasedOnUrlProperty>);
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_based_on_url)
2857				})?;
2858			} else {
2859				serialize_struct.skip_field("isBasedOnUrl")?;
2860			}
2861			if !Vec::is_empty(&self.r#is_family_friendly) {
2862				serialize_struct.serialize_field("isFamilyFriendly", {
2863					struct SerializeWith<'a>(&'a Vec<IsFamilyFriendlyProperty>);
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#is_family_friendly)
2875				})?;
2876			} else {
2877				serialize_struct.skip_field("isFamilyFriendly")?;
2878			}
2879			if !Vec::is_empty(&self.r#is_part_of) {
2880				serialize_struct.serialize_field("isPartOf", {
2881					struct SerializeWith<'a>(&'a Vec<IsPartOfProperty>);
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#is_part_of)
2893				})?;
2894			} else {
2895				serialize_struct.skip_field("isPartOf")?;
2896			}
2897			if !Vec::is_empty(&self.r#keywords) {
2898				serialize_struct.serialize_field("keywords", {
2899					struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
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#keywords)
2911				})?;
2912			} else {
2913				serialize_struct.skip_field("keywords")?;
2914			}
2915			if !Vec::is_empty(&self.r#learning_resource_type) {
2916				serialize_struct.serialize_field("learningResourceType", {
2917					struct SerializeWith<'a>(&'a Vec<LearningResourceTypeProperty>);
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#learning_resource_type)
2929				})?;
2930			} else {
2931				serialize_struct.skip_field("learningResourceType")?;
2932			}
2933			if !Vec::is_empty(&self.r#license) {
2934				serialize_struct.serialize_field("license", {
2935					struct SerializeWith<'a>(&'a Vec<LicenseProperty>);
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#license)
2947				})?;
2948			} else {
2949				serialize_struct.skip_field("license")?;
2950			}
2951			if !Vec::is_empty(&self.r#location_created) {
2952				serialize_struct.serialize_field("locationCreated", {
2953					struct SerializeWith<'a>(&'a Vec<LocationCreatedProperty>);
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#location_created)
2965				})?;
2966			} else {
2967				serialize_struct.skip_field("locationCreated")?;
2968			}
2969			if !Vec::is_empty(&self.r#main_entity) {
2970				serialize_struct.serialize_field("mainEntity", {
2971					struct SerializeWith<'a>(&'a Vec<MainEntityProperty>);
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#main_entity)
2983				})?;
2984			} else {
2985				serialize_struct.skip_field("mainEntity")?;
2986			}
2987			if !Vec::is_empty(&self.r#maintainer) {
2988				serialize_struct.serialize_field("maintainer", {
2989					struct SerializeWith<'a>(&'a Vec<MaintainerProperty>);
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#maintainer)
3001				})?;
3002			} else {
3003				serialize_struct.skip_field("maintainer")?;
3004			}
3005			if !Vec::is_empty(&self.r#material) {
3006				serialize_struct.serialize_field("material", {
3007					struct SerializeWith<'a>(&'a Vec<MaterialProperty>);
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#material)
3019				})?;
3020			} else {
3021				serialize_struct.skip_field("material")?;
3022			}
3023			if !Vec::is_empty(&self.r#material_extent) {
3024				serialize_struct.serialize_field("materialExtent", {
3025					struct SerializeWith<'a>(&'a Vec<MaterialExtentProperty>);
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#material_extent)
3037				})?;
3038			} else {
3039				serialize_struct.skip_field("materialExtent")?;
3040			}
3041			if !Vec::is_empty(&self.r#mentions) {
3042				serialize_struct.serialize_field("mentions", {
3043					struct SerializeWith<'a>(&'a Vec<MentionsProperty>);
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#mentions)
3055				})?;
3056			} else {
3057				serialize_struct.skip_field("mentions")?;
3058			}
3059			if !Vec::is_empty(&self.r#offers) {
3060				serialize_struct.serialize_field("offers", {
3061					struct SerializeWith<'a>(&'a Vec<OffersProperty>);
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#offers)
3073				})?;
3074			} else {
3075				serialize_struct.skip_field("offers")?;
3076			}
3077			if !Vec::is_empty(&self.r#pattern) {
3078				serialize_struct.serialize_field("pattern", {
3079					struct SerializeWith<'a>(&'a Vec<PatternProperty>);
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#pattern)
3091				})?;
3092			} else {
3093				serialize_struct.skip_field("pattern")?;
3094			}
3095			if !Vec::is_empty(&self.r#position) {
3096				serialize_struct.serialize_field("position", {
3097					struct SerializeWith<'a>(&'a Vec<PositionProperty>);
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#position)
3109				})?;
3110			} else {
3111				serialize_struct.skip_field("position")?;
3112			}
3113			if !Vec::is_empty(&self.r#producer) {
3114				serialize_struct.serialize_field("producer", {
3115					struct SerializeWith<'a>(&'a Vec<ProducerProperty>);
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#producer)
3127				})?;
3128			} else {
3129				serialize_struct.skip_field("producer")?;
3130			}
3131			if !Vec::is_empty(&self.r#provider) {
3132				serialize_struct.serialize_field("provider", {
3133					struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
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#provider)
3145				})?;
3146			} else {
3147				serialize_struct.skip_field("provider")?;
3148			}
3149			if !Vec::is_empty(&self.r#publication) {
3150				serialize_struct.serialize_field("publication", {
3151					struct SerializeWith<'a>(&'a Vec<PublicationProperty>);
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#publication)
3163				})?;
3164			} else {
3165				serialize_struct.skip_field("publication")?;
3166			}
3167			if !Vec::is_empty(&self.r#publisher) {
3168				serialize_struct.serialize_field("publisher", {
3169					struct SerializeWith<'a>(&'a Vec<PublisherProperty>);
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#publisher)
3181				})?;
3182			} else {
3183				serialize_struct.skip_field("publisher")?;
3184			}
3185			if !Vec::is_empty(&self.r#publisher_imprint) {
3186				serialize_struct.serialize_field("publisherImprint", {
3187					struct SerializeWith<'a>(&'a Vec<PublisherImprintProperty>);
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#publisher_imprint)
3199				})?;
3200			} else {
3201				serialize_struct.skip_field("publisherImprint")?;
3202			}
3203			if !Vec::is_empty(&self.r#publishing_principles) {
3204				serialize_struct.serialize_field("publishingPrinciples", {
3205					struct SerializeWith<'a>(&'a Vec<PublishingPrinciplesProperty>);
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#publishing_principles)
3217				})?;
3218			} else {
3219				serialize_struct.skip_field("publishingPrinciples")?;
3220			}
3221			if !Vec::is_empty(&self.r#recorded_at) {
3222				serialize_struct.serialize_field("recordedAt", {
3223					struct SerializeWith<'a>(&'a Vec<RecordedAtProperty>);
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#recorded_at)
3235				})?;
3236			} else {
3237				serialize_struct.skip_field("recordedAt")?;
3238			}
3239			if !Vec::is_empty(&self.r#released_event) {
3240				serialize_struct.serialize_field("releasedEvent", {
3241					struct SerializeWith<'a>(&'a Vec<ReleasedEventProperty>);
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#released_event)
3253				})?;
3254			} else {
3255				serialize_struct.skip_field("releasedEvent")?;
3256			}
3257			if !Vec::is_empty(&self.r#review) {
3258				serialize_struct.serialize_field("review", {
3259					struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
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#review)
3271				})?;
3272			} else {
3273				serialize_struct.skip_field("review")?;
3274			}
3275			if !Vec::is_empty(&self.r#reviews) {
3276				serialize_struct.serialize_field("reviews", {
3277					struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
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#reviews)
3289				})?;
3290			} else {
3291				serialize_struct.skip_field("reviews")?;
3292			}
3293			if !Vec::is_empty(&self.r#schema_version) {
3294				serialize_struct.serialize_field("schemaVersion", {
3295					struct SerializeWith<'a>(&'a Vec<SchemaVersionProperty>);
3296					impl<'a> Serialize for SerializeWith<'a> {
3297						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3298						where
3299							S: Serializer,
3300						{
3301							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3302								self.0, serializer,
3303							)
3304						}
3305					}
3306					&SerializeWith(&self.r#schema_version)
3307				})?;
3308			} else {
3309				serialize_struct.skip_field("schemaVersion")?;
3310			}
3311			if !Vec::is_empty(&self.r#sd_date_published) {
3312				serialize_struct.serialize_field("sdDatePublished", {
3313					struct SerializeWith<'a>(&'a Vec<SdDatePublishedProperty>);
3314					impl<'a> Serialize for SerializeWith<'a> {
3315						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3316						where
3317							S: Serializer,
3318						{
3319							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3320								self.0, serializer,
3321							)
3322						}
3323					}
3324					&SerializeWith(&self.r#sd_date_published)
3325				})?;
3326			} else {
3327				serialize_struct.skip_field("sdDatePublished")?;
3328			}
3329			if !Vec::is_empty(&self.r#sd_license) {
3330				serialize_struct.serialize_field("sdLicense", {
3331					struct SerializeWith<'a>(&'a Vec<SdLicenseProperty>);
3332					impl<'a> Serialize for SerializeWith<'a> {
3333						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3334						where
3335							S: Serializer,
3336						{
3337							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3338								self.0, serializer,
3339							)
3340						}
3341					}
3342					&SerializeWith(&self.r#sd_license)
3343				})?;
3344			} else {
3345				serialize_struct.skip_field("sdLicense")?;
3346			}
3347			if !Vec::is_empty(&self.r#sd_publisher) {
3348				serialize_struct.serialize_field("sdPublisher", {
3349					struct SerializeWith<'a>(&'a Vec<SdPublisherProperty>);
3350					impl<'a> Serialize for SerializeWith<'a> {
3351						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3352						where
3353							S: Serializer,
3354						{
3355							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3356								self.0, serializer,
3357							)
3358						}
3359					}
3360					&SerializeWith(&self.r#sd_publisher)
3361				})?;
3362			} else {
3363				serialize_struct.skip_field("sdPublisher")?;
3364			}
3365			if !Vec::is_empty(&self.r#size) {
3366				serialize_struct.serialize_field("size", {
3367					struct SerializeWith<'a>(&'a Vec<SizeProperty>);
3368					impl<'a> Serialize for SerializeWith<'a> {
3369						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3370						where
3371							S: Serializer,
3372						{
3373							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3374								self.0, serializer,
3375							)
3376						}
3377					}
3378					&SerializeWith(&self.r#size)
3379				})?;
3380			} else {
3381				serialize_struct.skip_field("size")?;
3382			}
3383			if !Vec::is_empty(&self.r#source_organization) {
3384				serialize_struct.serialize_field("sourceOrganization", {
3385					struct SerializeWith<'a>(&'a Vec<SourceOrganizationProperty>);
3386					impl<'a> Serialize for SerializeWith<'a> {
3387						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3388						where
3389							S: Serializer,
3390						{
3391							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3392								self.0, serializer,
3393							)
3394						}
3395					}
3396					&SerializeWith(&self.r#source_organization)
3397				})?;
3398			} else {
3399				serialize_struct.skip_field("sourceOrganization")?;
3400			}
3401			if !Vec::is_empty(&self.r#spatial) {
3402				serialize_struct.serialize_field("spatial", {
3403					struct SerializeWith<'a>(&'a Vec<SpatialProperty>);
3404					impl<'a> Serialize for SerializeWith<'a> {
3405						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3406						where
3407							S: Serializer,
3408						{
3409							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3410								self.0, serializer,
3411							)
3412						}
3413					}
3414					&SerializeWith(&self.r#spatial)
3415				})?;
3416			} else {
3417				serialize_struct.skip_field("spatial")?;
3418			}
3419			if !Vec::is_empty(&self.r#spatial_coverage) {
3420				serialize_struct.serialize_field("spatialCoverage", {
3421					struct SerializeWith<'a>(&'a Vec<SpatialCoverageProperty>);
3422					impl<'a> Serialize for SerializeWith<'a> {
3423						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3424						where
3425							S: Serializer,
3426						{
3427							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3428								self.0, serializer,
3429							)
3430						}
3431					}
3432					&SerializeWith(&self.r#spatial_coverage)
3433				})?;
3434			} else {
3435				serialize_struct.skip_field("spatialCoverage")?;
3436			}
3437			if !Vec::is_empty(&self.r#sponsor) {
3438				serialize_struct.serialize_field("sponsor", {
3439					struct SerializeWith<'a>(&'a Vec<SponsorProperty>);
3440					impl<'a> Serialize for SerializeWith<'a> {
3441						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3442						where
3443							S: Serializer,
3444						{
3445							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3446								self.0, serializer,
3447							)
3448						}
3449					}
3450					&SerializeWith(&self.r#sponsor)
3451				})?;
3452			} else {
3453				serialize_struct.skip_field("sponsor")?;
3454			}
3455			if !Vec::is_empty(&self.r#teaches) {
3456				serialize_struct.serialize_field("teaches", {
3457					struct SerializeWith<'a>(&'a Vec<TeachesProperty>);
3458					impl<'a> Serialize for SerializeWith<'a> {
3459						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3460						where
3461							S: Serializer,
3462						{
3463							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3464								self.0, serializer,
3465							)
3466						}
3467					}
3468					&SerializeWith(&self.r#teaches)
3469				})?;
3470			} else {
3471				serialize_struct.skip_field("teaches")?;
3472			}
3473			if !Vec::is_empty(&self.r#temporal) {
3474				serialize_struct.serialize_field("temporal", {
3475					struct SerializeWith<'a>(&'a Vec<TemporalProperty>);
3476					impl<'a> Serialize for SerializeWith<'a> {
3477						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3478						where
3479							S: Serializer,
3480						{
3481							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3482								self.0, serializer,
3483							)
3484						}
3485					}
3486					&SerializeWith(&self.r#temporal)
3487				})?;
3488			} else {
3489				serialize_struct.skip_field("temporal")?;
3490			}
3491			if !Vec::is_empty(&self.r#temporal_coverage) {
3492				serialize_struct.serialize_field("temporalCoverage", {
3493					struct SerializeWith<'a>(&'a Vec<TemporalCoverageProperty>);
3494					impl<'a> Serialize for SerializeWith<'a> {
3495						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3496						where
3497							S: Serializer,
3498						{
3499							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3500								self.0, serializer,
3501							)
3502						}
3503					}
3504					&SerializeWith(&self.r#temporal_coverage)
3505				})?;
3506			} else {
3507				serialize_struct.skip_field("temporalCoverage")?;
3508			}
3509			if !Vec::is_empty(&self.r#text) {
3510				serialize_struct.serialize_field("text", {
3511					struct SerializeWith<'a>(&'a Vec<TextProperty>);
3512					impl<'a> Serialize for SerializeWith<'a> {
3513						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3514						where
3515							S: Serializer,
3516						{
3517							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3518								self.0, serializer,
3519							)
3520						}
3521					}
3522					&SerializeWith(&self.r#text)
3523				})?;
3524			} else {
3525				serialize_struct.skip_field("text")?;
3526			}
3527			if !Vec::is_empty(&self.r#thumbnail) {
3528				serialize_struct.serialize_field("thumbnail", {
3529					struct SerializeWith<'a>(&'a Vec<ThumbnailProperty>);
3530					impl<'a> Serialize for SerializeWith<'a> {
3531						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3532						where
3533							S: Serializer,
3534						{
3535							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3536								self.0, serializer,
3537							)
3538						}
3539					}
3540					&SerializeWith(&self.r#thumbnail)
3541				})?;
3542			} else {
3543				serialize_struct.skip_field("thumbnail")?;
3544			}
3545			if !Vec::is_empty(&self.r#thumbnail_url) {
3546				serialize_struct.serialize_field("thumbnailUrl", {
3547					struct SerializeWith<'a>(&'a Vec<ThumbnailUrlProperty>);
3548					impl<'a> Serialize for SerializeWith<'a> {
3549						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3550						where
3551							S: Serializer,
3552						{
3553							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3554								self.0, serializer,
3555							)
3556						}
3557					}
3558					&SerializeWith(&self.r#thumbnail_url)
3559				})?;
3560			} else {
3561				serialize_struct.skip_field("thumbnailUrl")?;
3562			}
3563			if !Vec::is_empty(&self.r#time_required) {
3564				serialize_struct.serialize_field("timeRequired", {
3565					struct SerializeWith<'a>(&'a Vec<TimeRequiredProperty>);
3566					impl<'a> Serialize for SerializeWith<'a> {
3567						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3568						where
3569							S: Serializer,
3570						{
3571							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3572								self.0, serializer,
3573							)
3574						}
3575					}
3576					&SerializeWith(&self.r#time_required)
3577				})?;
3578			} else {
3579				serialize_struct.skip_field("timeRequired")?;
3580			}
3581			if !Vec::is_empty(&self.r#translation_of_work) {
3582				serialize_struct.serialize_field("translationOfWork", {
3583					struct SerializeWith<'a>(&'a Vec<TranslationOfWorkProperty>);
3584					impl<'a> Serialize for SerializeWith<'a> {
3585						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3586						where
3587							S: Serializer,
3588						{
3589							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3590								self.0, serializer,
3591							)
3592						}
3593					}
3594					&SerializeWith(&self.r#translation_of_work)
3595				})?;
3596			} else {
3597				serialize_struct.skip_field("translationOfWork")?;
3598			}
3599			if !Vec::is_empty(&self.r#translator) {
3600				serialize_struct.serialize_field("translator", {
3601					struct SerializeWith<'a>(&'a Vec<TranslatorProperty>);
3602					impl<'a> Serialize for SerializeWith<'a> {
3603						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3604						where
3605							S: Serializer,
3606						{
3607							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3608								self.0, serializer,
3609							)
3610						}
3611					}
3612					&SerializeWith(&self.r#translator)
3613				})?;
3614			} else {
3615				serialize_struct.skip_field("translator")?;
3616			}
3617			if !Vec::is_empty(&self.r#typical_age_range) {
3618				serialize_struct.serialize_field("typicalAgeRange", {
3619					struct SerializeWith<'a>(&'a Vec<TypicalAgeRangeProperty>);
3620					impl<'a> Serialize for SerializeWith<'a> {
3621						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3622						where
3623							S: Serializer,
3624						{
3625							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3626								self.0, serializer,
3627							)
3628						}
3629					}
3630					&SerializeWith(&self.r#typical_age_range)
3631				})?;
3632			} else {
3633				serialize_struct.skip_field("typicalAgeRange")?;
3634			}
3635			if !Vec::is_empty(&self.r#usage_info) {
3636				serialize_struct.serialize_field("usageInfo", {
3637					struct SerializeWith<'a>(&'a Vec<UsageInfoProperty>);
3638					impl<'a> Serialize for SerializeWith<'a> {
3639						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3640						where
3641							S: Serializer,
3642						{
3643							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3644								self.0, serializer,
3645							)
3646						}
3647					}
3648					&SerializeWith(&self.r#usage_info)
3649				})?;
3650			} else {
3651				serialize_struct.skip_field("usageInfo")?;
3652			}
3653			if !Vec::is_empty(&self.r#version) {
3654				serialize_struct.serialize_field("version", {
3655					struct SerializeWith<'a>(&'a Vec<VersionProperty>);
3656					impl<'a> Serialize for SerializeWith<'a> {
3657						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3658						where
3659							S: Serializer,
3660						{
3661							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3662								self.0, serializer,
3663							)
3664						}
3665					}
3666					&SerializeWith(&self.r#version)
3667				})?;
3668			} else {
3669				serialize_struct.skip_field("version")?;
3670			}
3671			if !Vec::is_empty(&self.r#video) {
3672				serialize_struct.serialize_field("video", {
3673					struct SerializeWith<'a>(&'a Vec<VideoProperty>);
3674					impl<'a> Serialize for SerializeWith<'a> {
3675						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3676						where
3677							S: Serializer,
3678						{
3679							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3680								self.0, serializer,
3681							)
3682						}
3683					}
3684					&SerializeWith(&self.r#video)
3685				})?;
3686			} else {
3687				serialize_struct.skip_field("video")?;
3688			}
3689			if !Vec::is_empty(&self.r#work_example) {
3690				serialize_struct.serialize_field("workExample", {
3691					struct SerializeWith<'a>(&'a Vec<WorkExampleProperty>);
3692					impl<'a> Serialize for SerializeWith<'a> {
3693						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3694						where
3695							S: Serializer,
3696						{
3697							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3698								self.0, serializer,
3699							)
3700						}
3701					}
3702					&SerializeWith(&self.r#work_example)
3703				})?;
3704			} else {
3705				serialize_struct.skip_field("workExample")?;
3706			}
3707			if !Vec::is_empty(&self.r#work_translation) {
3708				serialize_struct.serialize_field("workTranslation", {
3709					struct SerializeWith<'a>(&'a Vec<WorkTranslationProperty>);
3710					impl<'a> Serialize for SerializeWith<'a> {
3711						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3712						where
3713							S: Serializer,
3714						{
3715							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3716								self.0, serializer,
3717							)
3718						}
3719					}
3720					&SerializeWith(&self.r#work_translation)
3721				})?;
3722			} else {
3723				serialize_struct.skip_field("workTranslation")?;
3724			}
3725			if !Vec::is_empty(&self.r#additional_property) {
3726				serialize_struct.serialize_field("additionalProperty", {
3727					struct SerializeWith<'a>(&'a Vec<AdditionalPropertyProperty>);
3728					impl<'a> Serialize for SerializeWith<'a> {
3729						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3730						where
3731							S: Serializer,
3732						{
3733							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3734								self.0, serializer,
3735							)
3736						}
3737					}
3738					&SerializeWith(&self.r#additional_property)
3739				})?;
3740			} else {
3741				serialize_struct.skip_field("additionalProperty")?;
3742			}
3743			if !Vec::is_empty(&self.r#asin) {
3744				serialize_struct.serialize_field("asin", {
3745					struct SerializeWith<'a>(&'a Vec<AsinProperty>);
3746					impl<'a> Serialize for SerializeWith<'a> {
3747						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3748						where
3749							S: Serializer,
3750						{
3751							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3752								self.0, serializer,
3753							)
3754						}
3755					}
3756					&SerializeWith(&self.r#asin)
3757				})?;
3758			} else {
3759				serialize_struct.skip_field("asin")?;
3760			}
3761			if !Vec::is_empty(&self.r#brand) {
3762				serialize_struct.serialize_field("brand", {
3763					struct SerializeWith<'a>(&'a Vec<BrandProperty>);
3764					impl<'a> Serialize for SerializeWith<'a> {
3765						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3766						where
3767							S: Serializer,
3768						{
3769							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3770								self.0, serializer,
3771							)
3772						}
3773					}
3774					&SerializeWith(&self.r#brand)
3775				})?;
3776			} else {
3777				serialize_struct.skip_field("brand")?;
3778			}
3779			if !Vec::is_empty(&self.r#category) {
3780				serialize_struct.serialize_field("category", {
3781					struct SerializeWith<'a>(&'a Vec<CategoryProperty>);
3782					impl<'a> Serialize for SerializeWith<'a> {
3783						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3784						where
3785							S: Serializer,
3786						{
3787							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3788								self.0, serializer,
3789							)
3790						}
3791					}
3792					&SerializeWith(&self.r#category)
3793				})?;
3794			} else {
3795				serialize_struct.skip_field("category")?;
3796			}
3797			if !Vec::is_empty(&self.r#color) {
3798				serialize_struct.serialize_field("color", {
3799					struct SerializeWith<'a>(&'a Vec<ColorProperty>);
3800					impl<'a> Serialize for SerializeWith<'a> {
3801						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3802						where
3803							S: Serializer,
3804						{
3805							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3806								self.0, serializer,
3807							)
3808						}
3809					}
3810					&SerializeWith(&self.r#color)
3811				})?;
3812			} else {
3813				serialize_struct.skip_field("color")?;
3814			}
3815			if !Vec::is_empty(&self.r#country_of_assembly) {
3816				serialize_struct.serialize_field("countryOfAssembly", {
3817					struct SerializeWith<'a>(&'a Vec<CountryOfAssemblyProperty>);
3818					impl<'a> Serialize for SerializeWith<'a> {
3819						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3820						where
3821							S: Serializer,
3822						{
3823							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3824								self.0, serializer,
3825							)
3826						}
3827					}
3828					&SerializeWith(&self.r#country_of_assembly)
3829				})?;
3830			} else {
3831				serialize_struct.skip_field("countryOfAssembly")?;
3832			}
3833			if !Vec::is_empty(&self.r#country_of_last_processing) {
3834				serialize_struct.serialize_field("countryOfLastProcessing", {
3835					struct SerializeWith<'a>(&'a Vec<CountryOfLastProcessingProperty>);
3836					impl<'a> Serialize for SerializeWith<'a> {
3837						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3838						where
3839							S: Serializer,
3840						{
3841							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3842								self.0, serializer,
3843							)
3844						}
3845					}
3846					&SerializeWith(&self.r#country_of_last_processing)
3847				})?;
3848			} else {
3849				serialize_struct.skip_field("countryOfLastProcessing")?;
3850			}
3851			if !Vec::is_empty(&self.r#depth) {
3852				serialize_struct.serialize_field("depth", {
3853					struct SerializeWith<'a>(&'a Vec<DepthProperty>);
3854					impl<'a> Serialize for SerializeWith<'a> {
3855						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3856						where
3857							S: Serializer,
3858						{
3859							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3860								self.0, serializer,
3861							)
3862						}
3863					}
3864					&SerializeWith(&self.r#depth)
3865				})?;
3866			} else {
3867				serialize_struct.skip_field("depth")?;
3868			}
3869			if !Vec::is_empty(&self.r#gtin) {
3870				serialize_struct.serialize_field("gtin", {
3871					struct SerializeWith<'a>(&'a Vec<GtinProperty>);
3872					impl<'a> Serialize for SerializeWith<'a> {
3873						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3874						where
3875							S: Serializer,
3876						{
3877							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3878								self.0, serializer,
3879							)
3880						}
3881					}
3882					&SerializeWith(&self.r#gtin)
3883				})?;
3884			} else {
3885				serialize_struct.skip_field("gtin")?;
3886			}
3887			if !Vec::is_empty(&self.r#gtin_12) {
3888				serialize_struct.serialize_field("gtin12", {
3889					struct SerializeWith<'a>(&'a Vec<Gtin12Property>);
3890					impl<'a> Serialize for SerializeWith<'a> {
3891						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3892						where
3893							S: Serializer,
3894						{
3895							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3896								self.0, serializer,
3897							)
3898						}
3899					}
3900					&SerializeWith(&self.r#gtin_12)
3901				})?;
3902			} else {
3903				serialize_struct.skip_field("gtin12")?;
3904			}
3905			if !Vec::is_empty(&self.r#gtin_13) {
3906				serialize_struct.serialize_field("gtin13", {
3907					struct SerializeWith<'a>(&'a Vec<Gtin13Property>);
3908					impl<'a> Serialize for SerializeWith<'a> {
3909						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3910						where
3911							S: Serializer,
3912						{
3913							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3914								self.0, serializer,
3915							)
3916						}
3917					}
3918					&SerializeWith(&self.r#gtin_13)
3919				})?;
3920			} else {
3921				serialize_struct.skip_field("gtin13")?;
3922			}
3923			if !Vec::is_empty(&self.r#gtin_14) {
3924				serialize_struct.serialize_field("gtin14", {
3925					struct SerializeWith<'a>(&'a Vec<Gtin14Property>);
3926					impl<'a> Serialize for SerializeWith<'a> {
3927						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3928						where
3929							S: Serializer,
3930						{
3931							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3932								self.0, serializer,
3933							)
3934						}
3935					}
3936					&SerializeWith(&self.r#gtin_14)
3937				})?;
3938			} else {
3939				serialize_struct.skip_field("gtin14")?;
3940			}
3941			if !Vec::is_empty(&self.r#gtin_8) {
3942				serialize_struct.serialize_field("gtin8", {
3943					struct SerializeWith<'a>(&'a Vec<Gtin8Property>);
3944					impl<'a> Serialize for SerializeWith<'a> {
3945						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3946						where
3947							S: Serializer,
3948						{
3949							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3950								self.0, serializer,
3951							)
3952						}
3953					}
3954					&SerializeWith(&self.r#gtin_8)
3955				})?;
3956			} else {
3957				serialize_struct.skip_field("gtin8")?;
3958			}
3959			if !Vec::is_empty(&self.r#has_adult_consideration) {
3960				serialize_struct.serialize_field("hasAdultConsideration", {
3961					struct SerializeWith<'a>(&'a Vec<HasAdultConsiderationProperty>);
3962					impl<'a> Serialize for SerializeWith<'a> {
3963						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3964						where
3965							S: Serializer,
3966						{
3967							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3968								self.0, serializer,
3969							)
3970						}
3971					}
3972					&SerializeWith(&self.r#has_adult_consideration)
3973				})?;
3974			} else {
3975				serialize_struct.skip_field("hasAdultConsideration")?;
3976			}
3977			if !Vec::is_empty(&self.r#has_energy_consumption_details) {
3978				serialize_struct.serialize_field("hasEnergyConsumptionDetails", {
3979					struct SerializeWith<'a>(&'a Vec<HasEnergyConsumptionDetailsProperty>);
3980					impl<'a> Serialize for SerializeWith<'a> {
3981						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3982						where
3983							S: Serializer,
3984						{
3985							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3986								self.0, serializer,
3987							)
3988						}
3989					}
3990					&SerializeWith(&self.r#has_energy_consumption_details)
3991				})?;
3992			} else {
3993				serialize_struct.skip_field("hasEnergyConsumptionDetails")?;
3994			}
3995			if !Vec::is_empty(&self.r#has_measurement) {
3996				serialize_struct.serialize_field("hasMeasurement", {
3997					struct SerializeWith<'a>(&'a Vec<HasMeasurementProperty>);
3998					impl<'a> Serialize for SerializeWith<'a> {
3999						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4000						where
4001							S: Serializer,
4002						{
4003							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4004								self.0, serializer,
4005							)
4006						}
4007					}
4008					&SerializeWith(&self.r#has_measurement)
4009				})?;
4010			} else {
4011				serialize_struct.skip_field("hasMeasurement")?;
4012			}
4013			if !Vec::is_empty(&self.r#has_merchant_return_policy) {
4014				serialize_struct.serialize_field("hasMerchantReturnPolicy", {
4015					struct SerializeWith<'a>(&'a Vec<HasMerchantReturnPolicyProperty>);
4016					impl<'a> Serialize for SerializeWith<'a> {
4017						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4018						where
4019							S: Serializer,
4020						{
4021							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4022								self.0, serializer,
4023							)
4024						}
4025					}
4026					&SerializeWith(&self.r#has_merchant_return_policy)
4027				})?;
4028			} else {
4029				serialize_struct.skip_field("hasMerchantReturnPolicy")?;
4030			}
4031			if !Vec::is_empty(&self.r#has_product_return_policy) {
4032				serialize_struct.serialize_field("hasProductReturnPolicy", {
4033					struct SerializeWith<'a>(&'a Vec<HasProductReturnPolicyProperty>);
4034					impl<'a> Serialize for SerializeWith<'a> {
4035						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4036						where
4037							S: Serializer,
4038						{
4039							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4040								self.0, serializer,
4041							)
4042						}
4043					}
4044					&SerializeWith(&self.r#has_product_return_policy)
4045				})?;
4046			} else {
4047				serialize_struct.skip_field("hasProductReturnPolicy")?;
4048			}
4049			if !Vec::is_empty(&self.r#height) {
4050				serialize_struct.serialize_field("height", {
4051					struct SerializeWith<'a>(&'a Vec<HeightProperty>);
4052					impl<'a> Serialize for SerializeWith<'a> {
4053						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4054						where
4055							S: Serializer,
4056						{
4057							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4058								self.0, serializer,
4059							)
4060						}
4061					}
4062					&SerializeWith(&self.r#height)
4063				})?;
4064			} else {
4065				serialize_struct.skip_field("height")?;
4066			}
4067			if !Vec::is_empty(&self.r#in_product_group_with_id) {
4068				serialize_struct.serialize_field("inProductGroupWithID", {
4069					struct SerializeWith<'a>(&'a Vec<InProductGroupWithIdProperty>);
4070					impl<'a> Serialize for SerializeWith<'a> {
4071						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4072						where
4073							S: Serializer,
4074						{
4075							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4076								self.0, serializer,
4077							)
4078						}
4079					}
4080					&SerializeWith(&self.r#in_product_group_with_id)
4081				})?;
4082			} else {
4083				serialize_struct.skip_field("inProductGroupWithID")?;
4084			}
4085			if !Vec::is_empty(&self.r#is_accessory_or_spare_part_for) {
4086				serialize_struct.serialize_field("isAccessoryOrSparePartFor", {
4087					struct SerializeWith<'a>(&'a Vec<IsAccessoryOrSparePartForProperty>);
4088					impl<'a> Serialize for SerializeWith<'a> {
4089						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4090						where
4091							S: Serializer,
4092						{
4093							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4094								self.0, serializer,
4095							)
4096						}
4097					}
4098					&SerializeWith(&self.r#is_accessory_or_spare_part_for)
4099				})?;
4100			} else {
4101				serialize_struct.skip_field("isAccessoryOrSparePartFor")?;
4102			}
4103			if !Vec::is_empty(&self.r#is_consumable_for) {
4104				serialize_struct.serialize_field("isConsumableFor", {
4105					struct SerializeWith<'a>(&'a Vec<IsConsumableForProperty>);
4106					impl<'a> Serialize for SerializeWith<'a> {
4107						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4108						where
4109							S: Serializer,
4110						{
4111							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4112								self.0, serializer,
4113							)
4114						}
4115					}
4116					&SerializeWith(&self.r#is_consumable_for)
4117				})?;
4118			} else {
4119				serialize_struct.skip_field("isConsumableFor")?;
4120			}
4121			if !Vec::is_empty(&self.r#is_related_to) {
4122				serialize_struct.serialize_field("isRelatedTo", {
4123					struct SerializeWith<'a>(&'a Vec<IsRelatedToProperty>);
4124					impl<'a> Serialize for SerializeWith<'a> {
4125						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4126						where
4127							S: Serializer,
4128						{
4129							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4130								self.0, serializer,
4131							)
4132						}
4133					}
4134					&SerializeWith(&self.r#is_related_to)
4135				})?;
4136			} else {
4137				serialize_struct.skip_field("isRelatedTo")?;
4138			}
4139			if !Vec::is_empty(&self.r#is_similar_to) {
4140				serialize_struct.serialize_field("isSimilarTo", {
4141					struct SerializeWith<'a>(&'a Vec<IsSimilarToProperty>);
4142					impl<'a> Serialize for SerializeWith<'a> {
4143						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4144						where
4145							S: Serializer,
4146						{
4147							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4148								self.0, serializer,
4149							)
4150						}
4151					}
4152					&SerializeWith(&self.r#is_similar_to)
4153				})?;
4154			} else {
4155				serialize_struct.skip_field("isSimilarTo")?;
4156			}
4157			if !Vec::is_empty(&self.r#is_variant_of) {
4158				serialize_struct.serialize_field("isVariantOf", {
4159					struct SerializeWith<'a>(&'a Vec<IsVariantOfProperty>);
4160					impl<'a> Serialize for SerializeWith<'a> {
4161						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4162						where
4163							S: Serializer,
4164						{
4165							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4166								self.0, serializer,
4167							)
4168						}
4169					}
4170					&SerializeWith(&self.r#is_variant_of)
4171				})?;
4172			} else {
4173				serialize_struct.skip_field("isVariantOf")?;
4174			}
4175			if !Vec::is_empty(&self.r#item_condition) {
4176				serialize_struct.serialize_field("itemCondition", {
4177					struct SerializeWith<'a>(&'a Vec<ItemConditionProperty>);
4178					impl<'a> Serialize for SerializeWith<'a> {
4179						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4180						where
4181							S: Serializer,
4182						{
4183							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4184								self.0, serializer,
4185							)
4186						}
4187					}
4188					&SerializeWith(&self.r#item_condition)
4189				})?;
4190			} else {
4191				serialize_struct.skip_field("itemCondition")?;
4192			}
4193			if !Vec::is_empty(&self.r#logo) {
4194				serialize_struct.serialize_field("logo", {
4195					struct SerializeWith<'a>(&'a Vec<LogoProperty>);
4196					impl<'a> Serialize for SerializeWith<'a> {
4197						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4198						where
4199							S: Serializer,
4200						{
4201							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4202								self.0, serializer,
4203							)
4204						}
4205					}
4206					&SerializeWith(&self.r#logo)
4207				})?;
4208			} else {
4209				serialize_struct.skip_field("logo")?;
4210			}
4211			if !Vec::is_empty(&self.r#manufacturer) {
4212				serialize_struct.serialize_field("manufacturer", {
4213					struct SerializeWith<'a>(&'a Vec<ManufacturerProperty>);
4214					impl<'a> Serialize for SerializeWith<'a> {
4215						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4216						where
4217							S: Serializer,
4218						{
4219							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4220								self.0, serializer,
4221							)
4222						}
4223					}
4224					&SerializeWith(&self.r#manufacturer)
4225				})?;
4226			} else {
4227				serialize_struct.skip_field("manufacturer")?;
4228			}
4229			if !Vec::is_empty(&self.r#mobile_url) {
4230				serialize_struct.serialize_field("mobileUrl", {
4231					struct SerializeWith<'a>(&'a Vec<MobileUrlProperty>);
4232					impl<'a> Serialize for SerializeWith<'a> {
4233						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4234						where
4235							S: Serializer,
4236						{
4237							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4238								self.0, serializer,
4239							)
4240						}
4241					}
4242					&SerializeWith(&self.r#mobile_url)
4243				})?;
4244			} else {
4245				serialize_struct.skip_field("mobileUrl")?;
4246			}
4247			if !Vec::is_empty(&self.r#model) {
4248				serialize_struct.serialize_field("model", {
4249					struct SerializeWith<'a>(&'a Vec<ModelProperty>);
4250					impl<'a> Serialize for SerializeWith<'a> {
4251						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4252						where
4253							S: Serializer,
4254						{
4255							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4256								self.0, serializer,
4257							)
4258						}
4259					}
4260					&SerializeWith(&self.r#model)
4261				})?;
4262			} else {
4263				serialize_struct.skip_field("model")?;
4264			}
4265			if !Vec::is_empty(&self.r#mpn) {
4266				serialize_struct.serialize_field("mpn", {
4267					struct SerializeWith<'a>(&'a Vec<MpnProperty>);
4268					impl<'a> Serialize for SerializeWith<'a> {
4269						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4270						where
4271							S: Serializer,
4272						{
4273							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4274								self.0, serializer,
4275							)
4276						}
4277					}
4278					&SerializeWith(&self.r#mpn)
4279				})?;
4280			} else {
4281				serialize_struct.skip_field("mpn")?;
4282			}
4283			if !Vec::is_empty(&self.r#negative_notes) {
4284				serialize_struct.serialize_field("negativeNotes", {
4285					struct SerializeWith<'a>(&'a Vec<NegativeNotesProperty>);
4286					impl<'a> Serialize for SerializeWith<'a> {
4287						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4288						where
4289							S: Serializer,
4290						{
4291							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4292								self.0, serializer,
4293							)
4294						}
4295					}
4296					&SerializeWith(&self.r#negative_notes)
4297				})?;
4298			} else {
4299				serialize_struct.skip_field("negativeNotes")?;
4300			}
4301			if !Vec::is_empty(&self.r#nsn) {
4302				serialize_struct.serialize_field("nsn", {
4303					struct SerializeWith<'a>(&'a Vec<NsnProperty>);
4304					impl<'a> Serialize for SerializeWith<'a> {
4305						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4306						where
4307							S: Serializer,
4308						{
4309							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4310								self.0, serializer,
4311							)
4312						}
4313					}
4314					&SerializeWith(&self.r#nsn)
4315				})?;
4316			} else {
4317				serialize_struct.skip_field("nsn")?;
4318			}
4319			if !Vec::is_empty(&self.r#positive_notes) {
4320				serialize_struct.serialize_field("positiveNotes", {
4321					struct SerializeWith<'a>(&'a Vec<PositiveNotesProperty>);
4322					impl<'a> Serialize for SerializeWith<'a> {
4323						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4324						where
4325							S: Serializer,
4326						{
4327							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4328								self.0, serializer,
4329							)
4330						}
4331					}
4332					&SerializeWith(&self.r#positive_notes)
4333				})?;
4334			} else {
4335				serialize_struct.skip_field("positiveNotes")?;
4336			}
4337			if !Vec::is_empty(&self.r#product_id) {
4338				serialize_struct.serialize_field("productID", {
4339					struct SerializeWith<'a>(&'a Vec<ProductIdProperty>);
4340					impl<'a> Serialize for SerializeWith<'a> {
4341						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4342						where
4343							S: Serializer,
4344						{
4345							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4346								self.0, serializer,
4347							)
4348						}
4349					}
4350					&SerializeWith(&self.r#product_id)
4351				})?;
4352			} else {
4353				serialize_struct.skip_field("productID")?;
4354			}
4355			if !Vec::is_empty(&self.r#production_date) {
4356				serialize_struct.serialize_field("productionDate", {
4357					struct SerializeWith<'a>(&'a Vec<ProductionDateProperty>);
4358					impl<'a> Serialize for SerializeWith<'a> {
4359						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4360						where
4361							S: Serializer,
4362						{
4363							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4364								self.0, serializer,
4365							)
4366						}
4367					}
4368					&SerializeWith(&self.r#production_date)
4369				})?;
4370			} else {
4371				serialize_struct.skip_field("productionDate")?;
4372			}
4373			if !Vec::is_empty(&self.r#purchase_date) {
4374				serialize_struct.serialize_field("purchaseDate", {
4375					struct SerializeWith<'a>(&'a Vec<PurchaseDateProperty>);
4376					impl<'a> Serialize for SerializeWith<'a> {
4377						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4378						where
4379							S: Serializer,
4380						{
4381							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4382								self.0, serializer,
4383							)
4384						}
4385					}
4386					&SerializeWith(&self.r#purchase_date)
4387				})?;
4388			} else {
4389				serialize_struct.skip_field("purchaseDate")?;
4390			}
4391			if !Vec::is_empty(&self.r#release_date) {
4392				serialize_struct.serialize_field("releaseDate", {
4393					struct SerializeWith<'a>(&'a Vec<ReleaseDateProperty>);
4394					impl<'a> Serialize for SerializeWith<'a> {
4395						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4396						where
4397							S: Serializer,
4398						{
4399							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4400								self.0, serializer,
4401							)
4402						}
4403					}
4404					&SerializeWith(&self.r#release_date)
4405				})?;
4406			} else {
4407				serialize_struct.skip_field("releaseDate")?;
4408			}
4409			if !Vec::is_empty(&self.r#sku) {
4410				serialize_struct.serialize_field("sku", {
4411					struct SerializeWith<'a>(&'a Vec<SkuProperty>);
4412					impl<'a> Serialize for SerializeWith<'a> {
4413						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4414						where
4415							S: Serializer,
4416						{
4417							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4418								self.0, serializer,
4419							)
4420						}
4421					}
4422					&SerializeWith(&self.r#sku)
4423				})?;
4424			} else {
4425				serialize_struct.skip_field("sku")?;
4426			}
4427			if !Vec::is_empty(&self.r#slogan) {
4428				serialize_struct.serialize_field("slogan", {
4429					struct SerializeWith<'a>(&'a Vec<SloganProperty>);
4430					impl<'a> Serialize for SerializeWith<'a> {
4431						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4432						where
4433							S: Serializer,
4434						{
4435							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4436								self.0, serializer,
4437							)
4438						}
4439					}
4440					&SerializeWith(&self.r#slogan)
4441				})?;
4442			} else {
4443				serialize_struct.skip_field("slogan")?;
4444			}
4445			if !Vec::is_empty(&self.r#weight) {
4446				serialize_struct.serialize_field("weight", {
4447					struct SerializeWith<'a>(&'a Vec<WeightProperty>);
4448					impl<'a> Serialize for SerializeWith<'a> {
4449						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4450						where
4451							S: Serializer,
4452						{
4453							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4454								self.0, serializer,
4455							)
4456						}
4457					}
4458					&SerializeWith(&self.r#weight)
4459				})?;
4460			} else {
4461				serialize_struct.skip_field("weight")?;
4462			}
4463			if !Vec::is_empty(&self.r#width) {
4464				serialize_struct.serialize_field("width", {
4465					struct SerializeWith<'a>(&'a Vec<WidthProperty>);
4466					impl<'a> Serialize for SerializeWith<'a> {
4467						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4468						where
4469							S: Serializer,
4470						{
4471							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4472								self.0, serializer,
4473							)
4474						}
4475					}
4476					&SerializeWith(&self.r#width)
4477				})?;
4478			} else {
4479				serialize_struct.skip_field("width")?;
4480			}
4481			if !Vec::is_empty(&self.r#additional_type) {
4482				serialize_struct.serialize_field("additionalType", {
4483					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
4484					impl<'a> Serialize for SerializeWith<'a> {
4485						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4486						where
4487							S: Serializer,
4488						{
4489							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4490								self.0, serializer,
4491							)
4492						}
4493					}
4494					&SerializeWith(&self.r#additional_type)
4495				})?;
4496			} else {
4497				serialize_struct.skip_field("additionalType")?;
4498			}
4499			if !Vec::is_empty(&self.r#alternate_name) {
4500				serialize_struct.serialize_field("alternateName", {
4501					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
4502					impl<'a> Serialize for SerializeWith<'a> {
4503						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4504						where
4505							S: Serializer,
4506						{
4507							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4508								self.0, serializer,
4509							)
4510						}
4511					}
4512					&SerializeWith(&self.r#alternate_name)
4513				})?;
4514			} else {
4515				serialize_struct.skip_field("alternateName")?;
4516			}
4517			if !Vec::is_empty(&self.r#description) {
4518				serialize_struct.serialize_field("description", {
4519					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
4520					impl<'a> Serialize for SerializeWith<'a> {
4521						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4522						where
4523							S: Serializer,
4524						{
4525							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4526								self.0, serializer,
4527							)
4528						}
4529					}
4530					&SerializeWith(&self.r#description)
4531				})?;
4532			} else {
4533				serialize_struct.skip_field("description")?;
4534			}
4535			if !Vec::is_empty(&self.r#disambiguating_description) {
4536				serialize_struct.serialize_field("disambiguatingDescription", {
4537					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
4538					impl<'a> Serialize for SerializeWith<'a> {
4539						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4540						where
4541							S: Serializer,
4542						{
4543							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4544								self.0, serializer,
4545							)
4546						}
4547					}
4548					&SerializeWith(&self.r#disambiguating_description)
4549				})?;
4550			} else {
4551				serialize_struct.skip_field("disambiguatingDescription")?;
4552			}
4553			if !Vec::is_empty(&self.r#identifier) {
4554				serialize_struct.serialize_field("identifier", {
4555					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
4556					impl<'a> Serialize for SerializeWith<'a> {
4557						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4558						where
4559							S: Serializer,
4560						{
4561							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4562								self.0, serializer,
4563							)
4564						}
4565					}
4566					&SerializeWith(&self.r#identifier)
4567				})?;
4568			} else {
4569				serialize_struct.skip_field("identifier")?;
4570			}
4571			if !Vec::is_empty(&self.r#image) {
4572				serialize_struct.serialize_field("image", {
4573					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
4574					impl<'a> Serialize for SerializeWith<'a> {
4575						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4576						where
4577							S: Serializer,
4578						{
4579							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4580								self.0, serializer,
4581							)
4582						}
4583					}
4584					&SerializeWith(&self.r#image)
4585				})?;
4586			} else {
4587				serialize_struct.skip_field("image")?;
4588			}
4589			if !Vec::is_empty(&self.r#main_entity_of_page) {
4590				serialize_struct.serialize_field("mainEntityOfPage", {
4591					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
4592					impl<'a> Serialize for SerializeWith<'a> {
4593						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4594						where
4595							S: Serializer,
4596						{
4597							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4598								self.0, serializer,
4599							)
4600						}
4601					}
4602					&SerializeWith(&self.r#main_entity_of_page)
4603				})?;
4604			} else {
4605				serialize_struct.skip_field("mainEntityOfPage")?;
4606			}
4607			if !Vec::is_empty(&self.r#name) {
4608				serialize_struct.serialize_field("name", {
4609					struct SerializeWith<'a>(&'a Vec<NameProperty>);
4610					impl<'a> Serialize for SerializeWith<'a> {
4611						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4612						where
4613							S: Serializer,
4614						{
4615							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4616								self.0, serializer,
4617							)
4618						}
4619					}
4620					&SerializeWith(&self.r#name)
4621				})?;
4622			} else {
4623				serialize_struct.skip_field("name")?;
4624			}
4625			if !Vec::is_empty(&self.r#potential_action) {
4626				serialize_struct.serialize_field("potentialAction", {
4627					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
4628					impl<'a> Serialize for SerializeWith<'a> {
4629						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4630						where
4631							S: Serializer,
4632						{
4633							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4634								self.0, serializer,
4635							)
4636						}
4637					}
4638					&SerializeWith(&self.r#potential_action)
4639				})?;
4640			} else {
4641				serialize_struct.skip_field("potentialAction")?;
4642			}
4643			if !Vec::is_empty(&self.r#same_as) {
4644				serialize_struct.serialize_field("sameAs", {
4645					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
4646					impl<'a> Serialize for SerializeWith<'a> {
4647						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4648						where
4649							S: Serializer,
4650						{
4651							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4652								self.0, serializer,
4653							)
4654						}
4655					}
4656					&SerializeWith(&self.r#same_as)
4657				})?;
4658			} else {
4659				serialize_struct.skip_field("sameAs")?;
4660			}
4661			if !Vec::is_empty(&self.r#subject_of) {
4662				serialize_struct.serialize_field("subjectOf", {
4663					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
4664					impl<'a> Serialize for SerializeWith<'a> {
4665						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4666						where
4667							S: Serializer,
4668						{
4669							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4670								self.0, serializer,
4671							)
4672						}
4673					}
4674					&SerializeWith(&self.r#subject_of)
4675				})?;
4676			} else {
4677				serialize_struct.skip_field("subjectOf")?;
4678			}
4679			if !Vec::is_empty(&self.r#url) {
4680				serialize_struct.serialize_field("url", {
4681					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
4682					impl<'a> Serialize for SerializeWith<'a> {
4683						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4684						where
4685							S: Serializer,
4686						{
4687							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4688								self.0, serializer,
4689							)
4690						}
4691					}
4692					&SerializeWith(&self.r#url)
4693				})?;
4694			} else {
4695				serialize_struct.skip_field("url")?;
4696			}
4697			serialize_struct.end()
4698		}
4699	}
4700	impl<'de> Deserialize<'de> for ProductCollection {
4701		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4702		where
4703			D: Deserializer<'de>,
4704		{
4705			enum Field {
4706				IncludesObject,
4707				CollectionSize,
4708				About,
4709				Abstract,
4710				AccessMode,
4711				AccessModeSufficient,
4712				AccessibilityApi,
4713				AccessibilityControl,
4714				AccessibilityFeature,
4715				AccessibilityHazard,
4716				AccessibilitySummary,
4717				AccountablePerson,
4718				AcquireLicensePage,
4719				AggregateRating,
4720				AlternativeHeadline,
4721				ArchivedAt,
4722				Assesses,
4723				AssociatedMedia,
4724				Audience,
4725				Audio,
4726				Author,
4727				Award,
4728				Awards,
4729				Character,
4730				Citation,
4731				Comment,
4732				CommentCount,
4733				ConditionsOfAccess,
4734				ContentLocation,
4735				ContentRating,
4736				ContentReferenceTime,
4737				Contributor,
4738				CopyrightHolder,
4739				CopyrightNotice,
4740				CopyrightYear,
4741				Correction,
4742				CountryOfOrigin,
4743				CreativeWorkStatus,
4744				Creator,
4745				CreditText,
4746				DateCreated,
4747				DateModified,
4748				DatePublished,
4749				DiscussionUrl,
4750				EditEidr,
4751				Editor,
4752				EducationalAlignment,
4753				EducationalLevel,
4754				EducationalUse,
4755				Encoding,
4756				EncodingFormat,
4757				Encodings,
4758				ExampleOfWork,
4759				Expires,
4760				FileFormat,
4761				Funder,
4762				Funding,
4763				Genre,
4764				HasPart,
4765				Headline,
4766				InLanguage,
4767				InteractionStatistic,
4768				InteractivityType,
4769				InterpretedAsClaim,
4770				IsAccessibleForFree,
4771				IsBasedOn,
4772				IsBasedOnUrl,
4773				IsFamilyFriendly,
4774				IsPartOf,
4775				Keywords,
4776				LearningResourceType,
4777				License,
4778				LocationCreated,
4779				MainEntity,
4780				Maintainer,
4781				Material,
4782				MaterialExtent,
4783				Mentions,
4784				Offers,
4785				Pattern,
4786				Position,
4787				Producer,
4788				Provider,
4789				Publication,
4790				Publisher,
4791				PublisherImprint,
4792				PublishingPrinciples,
4793				RecordedAt,
4794				ReleasedEvent,
4795				Review,
4796				Reviews,
4797				SchemaVersion,
4798				SdDatePublished,
4799				SdLicense,
4800				SdPublisher,
4801				Size,
4802				SourceOrganization,
4803				Spatial,
4804				SpatialCoverage,
4805				Sponsor,
4806				Teaches,
4807				Temporal,
4808				TemporalCoverage,
4809				Text,
4810				Thumbnail,
4811				ThumbnailUrl,
4812				TimeRequired,
4813				TranslationOfWork,
4814				Translator,
4815				TypicalAgeRange,
4816				UsageInfo,
4817				Version,
4818				Video,
4819				WorkExample,
4820				WorkTranslation,
4821				AdditionalProperty,
4822				Asin,
4823				Brand,
4824				Category,
4825				Color,
4826				CountryOfAssembly,
4827				CountryOfLastProcessing,
4828				Depth,
4829				Gtin,
4830				Gtin12,
4831				Gtin13,
4832				Gtin14,
4833				Gtin8,
4834				HasAdultConsideration,
4835				HasEnergyConsumptionDetails,
4836				HasMeasurement,
4837				HasMerchantReturnPolicy,
4838				HasProductReturnPolicy,
4839				Height,
4840				InProductGroupWithId,
4841				IsAccessoryOrSparePartFor,
4842				IsConsumableFor,
4843				IsRelatedTo,
4844				IsSimilarTo,
4845				IsVariantOf,
4846				ItemCondition,
4847				Logo,
4848				Manufacturer,
4849				MobileUrl,
4850				Model,
4851				Mpn,
4852				NegativeNotes,
4853				Nsn,
4854				PositiveNotes,
4855				ProductId,
4856				ProductionDate,
4857				PurchaseDate,
4858				ReleaseDate,
4859				Sku,
4860				Slogan,
4861				Weight,
4862				Width,
4863				AdditionalType,
4864				AlternateName,
4865				Description,
4866				DisambiguatingDescription,
4867				Identifier,
4868				Image,
4869				MainEntityOfPage,
4870				Name,
4871				PotentialAction,
4872				SameAs,
4873				SubjectOf,
4874				Url,
4875				Ignore,
4876			}
4877			struct FieldVisitor;
4878			impl<'de> Visitor<'de> for FieldVisitor {
4879				type Value = Field;
4880				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
4881					formatter.write_str("field identifier")
4882				}
4883				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
4884				where
4885					E: de::Error,
4886				{
4887					match value {
4888						"includesObject" => Ok(Field::IncludesObject),
4889						"collectionSize" => Ok(Field::CollectionSize),
4890						"about" => Ok(Field::About),
4891						"abstract" => Ok(Field::Abstract),
4892						"accessMode" => Ok(Field::AccessMode),
4893						"accessModeSufficient" => Ok(Field::AccessModeSufficient),
4894						"accessibilityAPI" => Ok(Field::AccessibilityApi),
4895						"accessibilityControl" => Ok(Field::AccessibilityControl),
4896						"accessibilityFeature" => Ok(Field::AccessibilityFeature),
4897						"accessibilityHazard" => Ok(Field::AccessibilityHazard),
4898						"accessibilitySummary" => Ok(Field::AccessibilitySummary),
4899						"accountablePerson" => Ok(Field::AccountablePerson),
4900						"acquireLicensePage" => Ok(Field::AcquireLicensePage),
4901						"aggregateRating" => Ok(Field::AggregateRating),
4902						"alternativeHeadline" => Ok(Field::AlternativeHeadline),
4903						"archivedAt" => Ok(Field::ArchivedAt),
4904						"assesses" => Ok(Field::Assesses),
4905						"associatedMedia" => Ok(Field::AssociatedMedia),
4906						"audience" => Ok(Field::Audience),
4907						"audio" => Ok(Field::Audio),
4908						"author" => Ok(Field::Author),
4909						"award" => Ok(Field::Award),
4910						"awards" => Ok(Field::Awards),
4911						"character" => Ok(Field::Character),
4912						"citation" => Ok(Field::Citation),
4913						"comment" => Ok(Field::Comment),
4914						"commentCount" => Ok(Field::CommentCount),
4915						"conditionsOfAccess" => Ok(Field::ConditionsOfAccess),
4916						"contentLocation" => Ok(Field::ContentLocation),
4917						"contentRating" => Ok(Field::ContentRating),
4918						"contentReferenceTime" => Ok(Field::ContentReferenceTime),
4919						"contributor" => Ok(Field::Contributor),
4920						"copyrightHolder" => Ok(Field::CopyrightHolder),
4921						"copyrightNotice" => Ok(Field::CopyrightNotice),
4922						"copyrightYear" => Ok(Field::CopyrightYear),
4923						"correction" => Ok(Field::Correction),
4924						"countryOfOrigin" => Ok(Field::CountryOfOrigin),
4925						"creativeWorkStatus" => Ok(Field::CreativeWorkStatus),
4926						"creator" => Ok(Field::Creator),
4927						"creditText" => Ok(Field::CreditText),
4928						"dateCreated" => Ok(Field::DateCreated),
4929						"dateModified" => Ok(Field::DateModified),
4930						"datePublished" => Ok(Field::DatePublished),
4931						"discussionUrl" => Ok(Field::DiscussionUrl),
4932						"editEIDR" => Ok(Field::EditEidr),
4933						"editor" => Ok(Field::Editor),
4934						"educationalAlignment" => Ok(Field::EducationalAlignment),
4935						"educationalLevel" => Ok(Field::EducationalLevel),
4936						"educationalUse" => Ok(Field::EducationalUse),
4937						"encoding" => Ok(Field::Encoding),
4938						"encodingFormat" => Ok(Field::EncodingFormat),
4939						"encodings" => Ok(Field::Encodings),
4940						"exampleOfWork" => Ok(Field::ExampleOfWork),
4941						"expires" => Ok(Field::Expires),
4942						"fileFormat" => Ok(Field::FileFormat),
4943						"funder" => Ok(Field::Funder),
4944						"funding" => Ok(Field::Funding),
4945						"genre" => Ok(Field::Genre),
4946						"hasPart" => Ok(Field::HasPart),
4947						"headline" => Ok(Field::Headline),
4948						"inLanguage" => Ok(Field::InLanguage),
4949						"interactionStatistic" => Ok(Field::InteractionStatistic),
4950						"interactivityType" => Ok(Field::InteractivityType),
4951						"interpretedAsClaim" => Ok(Field::InterpretedAsClaim),
4952						"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
4953						"isBasedOn" => Ok(Field::IsBasedOn),
4954						"isBasedOnUrl" => Ok(Field::IsBasedOnUrl),
4955						"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
4956						"isPartOf" => Ok(Field::IsPartOf),
4957						"keywords" => Ok(Field::Keywords),
4958						"learningResourceType" => Ok(Field::LearningResourceType),
4959						"license" => Ok(Field::License),
4960						"locationCreated" => Ok(Field::LocationCreated),
4961						"mainEntity" => Ok(Field::MainEntity),
4962						"maintainer" => Ok(Field::Maintainer),
4963						"material" => Ok(Field::Material),
4964						"materialExtent" => Ok(Field::MaterialExtent),
4965						"mentions" => Ok(Field::Mentions),
4966						"offers" => Ok(Field::Offers),
4967						"pattern" => Ok(Field::Pattern),
4968						"position" => Ok(Field::Position),
4969						"producer" => Ok(Field::Producer),
4970						"provider" => Ok(Field::Provider),
4971						"publication" => Ok(Field::Publication),
4972						"publisher" => Ok(Field::Publisher),
4973						"publisherImprint" => Ok(Field::PublisherImprint),
4974						"publishingPrinciples" => Ok(Field::PublishingPrinciples),
4975						"recordedAt" => Ok(Field::RecordedAt),
4976						"releasedEvent" => Ok(Field::ReleasedEvent),
4977						"review" => Ok(Field::Review),
4978						"reviews" => Ok(Field::Reviews),
4979						"schemaVersion" => Ok(Field::SchemaVersion),
4980						"sdDatePublished" => Ok(Field::SdDatePublished),
4981						"sdLicense" => Ok(Field::SdLicense),
4982						"sdPublisher" => Ok(Field::SdPublisher),
4983						"size" => Ok(Field::Size),
4984						"sourceOrganization" => Ok(Field::SourceOrganization),
4985						"spatial" => Ok(Field::Spatial),
4986						"spatialCoverage" => Ok(Field::SpatialCoverage),
4987						"sponsor" => Ok(Field::Sponsor),
4988						"teaches" => Ok(Field::Teaches),
4989						"temporal" => Ok(Field::Temporal),
4990						"temporalCoverage" => Ok(Field::TemporalCoverage),
4991						"text" => Ok(Field::Text),
4992						"thumbnail" => Ok(Field::Thumbnail),
4993						"thumbnailUrl" => Ok(Field::ThumbnailUrl),
4994						"timeRequired" => Ok(Field::TimeRequired),
4995						"translationOfWork" => Ok(Field::TranslationOfWork),
4996						"translator" => Ok(Field::Translator),
4997						"typicalAgeRange" => Ok(Field::TypicalAgeRange),
4998						"usageInfo" => Ok(Field::UsageInfo),
4999						"version" => Ok(Field::Version),
5000						"video" => Ok(Field::Video),
5001						"workExample" => Ok(Field::WorkExample),
5002						"workTranslation" => Ok(Field::WorkTranslation),
5003						"additionalProperty" => Ok(Field::AdditionalProperty),
5004						"asin" => Ok(Field::Asin),
5005						"brand" => Ok(Field::Brand),
5006						"category" => Ok(Field::Category),
5007						"color" => Ok(Field::Color),
5008						"countryOfAssembly" => Ok(Field::CountryOfAssembly),
5009						"countryOfLastProcessing" => Ok(Field::CountryOfLastProcessing),
5010						"depth" => Ok(Field::Depth),
5011						"gtin" => Ok(Field::Gtin),
5012						"gtin12" => Ok(Field::Gtin12),
5013						"gtin13" => Ok(Field::Gtin13),
5014						"gtin14" => Ok(Field::Gtin14),
5015						"gtin8" => Ok(Field::Gtin8),
5016						"hasAdultConsideration" => Ok(Field::HasAdultConsideration),
5017						"hasEnergyConsumptionDetails" => Ok(Field::HasEnergyConsumptionDetails),
5018						"hasMeasurement" => Ok(Field::HasMeasurement),
5019						"hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
5020						"hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
5021						"height" => Ok(Field::Height),
5022						"inProductGroupWithID" => Ok(Field::InProductGroupWithId),
5023						"isAccessoryOrSparePartFor" => Ok(Field::IsAccessoryOrSparePartFor),
5024						"isConsumableFor" => Ok(Field::IsConsumableFor),
5025						"isRelatedTo" => Ok(Field::IsRelatedTo),
5026						"isSimilarTo" => Ok(Field::IsSimilarTo),
5027						"isVariantOf" => Ok(Field::IsVariantOf),
5028						"itemCondition" => Ok(Field::ItemCondition),
5029						"logo" => Ok(Field::Logo),
5030						"manufacturer" => Ok(Field::Manufacturer),
5031						"mobileUrl" => Ok(Field::MobileUrl),
5032						"model" => Ok(Field::Model),
5033						"mpn" => Ok(Field::Mpn),
5034						"negativeNotes" => Ok(Field::NegativeNotes),
5035						"nsn" => Ok(Field::Nsn),
5036						"positiveNotes" => Ok(Field::PositiveNotes),
5037						"productID" => Ok(Field::ProductId),
5038						"productionDate" => Ok(Field::ProductionDate),
5039						"purchaseDate" => Ok(Field::PurchaseDate),
5040						"releaseDate" => Ok(Field::ReleaseDate),
5041						"sku" => Ok(Field::Sku),
5042						"slogan" => Ok(Field::Slogan),
5043						"weight" => Ok(Field::Weight),
5044						"width" => Ok(Field::Width),
5045						"additionalType" => Ok(Field::AdditionalType),
5046						"alternateName" => Ok(Field::AlternateName),
5047						"description" => Ok(Field::Description),
5048						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
5049						"identifier" => Ok(Field::Identifier),
5050						"image" => Ok(Field::Image),
5051						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
5052						"name" => Ok(Field::Name),
5053						"potentialAction" => Ok(Field::PotentialAction),
5054						"sameAs" => Ok(Field::SameAs),
5055						"subjectOf" => Ok(Field::SubjectOf),
5056						"url" => Ok(Field::Url),
5057						"id" | "type" => Ok(Field::Ignore),
5058						_ => Err(de::Error::unknown_field(value, FIELDS)),
5059					}
5060				}
5061				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
5062				where
5063					E: de::Error,
5064				{
5065					match value {
5066						b"includesObject" => Ok(Field::IncludesObject),
5067						b"collectionSize" => Ok(Field::CollectionSize),
5068						b"about" => Ok(Field::About),
5069						b"abstract" => Ok(Field::Abstract),
5070						b"accessMode" => Ok(Field::AccessMode),
5071						b"accessModeSufficient" => Ok(Field::AccessModeSufficient),
5072						b"accessibilityAPI" => Ok(Field::AccessibilityApi),
5073						b"accessibilityControl" => Ok(Field::AccessibilityControl),
5074						b"accessibilityFeature" => Ok(Field::AccessibilityFeature),
5075						b"accessibilityHazard" => Ok(Field::AccessibilityHazard),
5076						b"accessibilitySummary" => Ok(Field::AccessibilitySummary),
5077						b"accountablePerson" => Ok(Field::AccountablePerson),
5078						b"acquireLicensePage" => Ok(Field::AcquireLicensePage),
5079						b"aggregateRating" => Ok(Field::AggregateRating),
5080						b"alternativeHeadline" => Ok(Field::AlternativeHeadline),
5081						b"archivedAt" => Ok(Field::ArchivedAt),
5082						b"assesses" => Ok(Field::Assesses),
5083						b"associatedMedia" => Ok(Field::AssociatedMedia),
5084						b"audience" => Ok(Field::Audience),
5085						b"audio" => Ok(Field::Audio),
5086						b"author" => Ok(Field::Author),
5087						b"award" => Ok(Field::Award),
5088						b"awards" => Ok(Field::Awards),
5089						b"character" => Ok(Field::Character),
5090						b"citation" => Ok(Field::Citation),
5091						b"comment" => Ok(Field::Comment),
5092						b"commentCount" => Ok(Field::CommentCount),
5093						b"conditionsOfAccess" => Ok(Field::ConditionsOfAccess),
5094						b"contentLocation" => Ok(Field::ContentLocation),
5095						b"contentRating" => Ok(Field::ContentRating),
5096						b"contentReferenceTime" => Ok(Field::ContentReferenceTime),
5097						b"contributor" => Ok(Field::Contributor),
5098						b"copyrightHolder" => Ok(Field::CopyrightHolder),
5099						b"copyrightNotice" => Ok(Field::CopyrightNotice),
5100						b"copyrightYear" => Ok(Field::CopyrightYear),
5101						b"correction" => Ok(Field::Correction),
5102						b"countryOfOrigin" => Ok(Field::CountryOfOrigin),
5103						b"creativeWorkStatus" => Ok(Field::CreativeWorkStatus),
5104						b"creator" => Ok(Field::Creator),
5105						b"creditText" => Ok(Field::CreditText),
5106						b"dateCreated" => Ok(Field::DateCreated),
5107						b"dateModified" => Ok(Field::DateModified),
5108						b"datePublished" => Ok(Field::DatePublished),
5109						b"discussionUrl" => Ok(Field::DiscussionUrl),
5110						b"editEIDR" => Ok(Field::EditEidr),
5111						b"editor" => Ok(Field::Editor),
5112						b"educationalAlignment" => Ok(Field::EducationalAlignment),
5113						b"educationalLevel" => Ok(Field::EducationalLevel),
5114						b"educationalUse" => Ok(Field::EducationalUse),
5115						b"encoding" => Ok(Field::Encoding),
5116						b"encodingFormat" => Ok(Field::EncodingFormat),
5117						b"encodings" => Ok(Field::Encodings),
5118						b"exampleOfWork" => Ok(Field::ExampleOfWork),
5119						b"expires" => Ok(Field::Expires),
5120						b"fileFormat" => Ok(Field::FileFormat),
5121						b"funder" => Ok(Field::Funder),
5122						b"funding" => Ok(Field::Funding),
5123						b"genre" => Ok(Field::Genre),
5124						b"hasPart" => Ok(Field::HasPart),
5125						b"headline" => Ok(Field::Headline),
5126						b"inLanguage" => Ok(Field::InLanguage),
5127						b"interactionStatistic" => Ok(Field::InteractionStatistic),
5128						b"interactivityType" => Ok(Field::InteractivityType),
5129						b"interpretedAsClaim" => Ok(Field::InterpretedAsClaim),
5130						b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
5131						b"isBasedOn" => Ok(Field::IsBasedOn),
5132						b"isBasedOnUrl" => Ok(Field::IsBasedOnUrl),
5133						b"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
5134						b"isPartOf" => Ok(Field::IsPartOf),
5135						b"keywords" => Ok(Field::Keywords),
5136						b"learningResourceType" => Ok(Field::LearningResourceType),
5137						b"license" => Ok(Field::License),
5138						b"locationCreated" => Ok(Field::LocationCreated),
5139						b"mainEntity" => Ok(Field::MainEntity),
5140						b"maintainer" => Ok(Field::Maintainer),
5141						b"material" => Ok(Field::Material),
5142						b"materialExtent" => Ok(Field::MaterialExtent),
5143						b"mentions" => Ok(Field::Mentions),
5144						b"offers" => Ok(Field::Offers),
5145						b"pattern" => Ok(Field::Pattern),
5146						b"position" => Ok(Field::Position),
5147						b"producer" => Ok(Field::Producer),
5148						b"provider" => Ok(Field::Provider),
5149						b"publication" => Ok(Field::Publication),
5150						b"publisher" => Ok(Field::Publisher),
5151						b"publisherImprint" => Ok(Field::PublisherImprint),
5152						b"publishingPrinciples" => Ok(Field::PublishingPrinciples),
5153						b"recordedAt" => Ok(Field::RecordedAt),
5154						b"releasedEvent" => Ok(Field::ReleasedEvent),
5155						b"review" => Ok(Field::Review),
5156						b"reviews" => Ok(Field::Reviews),
5157						b"schemaVersion" => Ok(Field::SchemaVersion),
5158						b"sdDatePublished" => Ok(Field::SdDatePublished),
5159						b"sdLicense" => Ok(Field::SdLicense),
5160						b"sdPublisher" => Ok(Field::SdPublisher),
5161						b"size" => Ok(Field::Size),
5162						b"sourceOrganization" => Ok(Field::SourceOrganization),
5163						b"spatial" => Ok(Field::Spatial),
5164						b"spatialCoverage" => Ok(Field::SpatialCoverage),
5165						b"sponsor" => Ok(Field::Sponsor),
5166						b"teaches" => Ok(Field::Teaches),
5167						b"temporal" => Ok(Field::Temporal),
5168						b"temporalCoverage" => Ok(Field::TemporalCoverage),
5169						b"text" => Ok(Field::Text),
5170						b"thumbnail" => Ok(Field::Thumbnail),
5171						b"thumbnailUrl" => Ok(Field::ThumbnailUrl),
5172						b"timeRequired" => Ok(Field::TimeRequired),
5173						b"translationOfWork" => Ok(Field::TranslationOfWork),
5174						b"translator" => Ok(Field::Translator),
5175						b"typicalAgeRange" => Ok(Field::TypicalAgeRange),
5176						b"usageInfo" => Ok(Field::UsageInfo),
5177						b"version" => Ok(Field::Version),
5178						b"video" => Ok(Field::Video),
5179						b"workExample" => Ok(Field::WorkExample),
5180						b"workTranslation" => Ok(Field::WorkTranslation),
5181						b"additionalProperty" => Ok(Field::AdditionalProperty),
5182						b"asin" => Ok(Field::Asin),
5183						b"brand" => Ok(Field::Brand),
5184						b"category" => Ok(Field::Category),
5185						b"color" => Ok(Field::Color),
5186						b"countryOfAssembly" => Ok(Field::CountryOfAssembly),
5187						b"countryOfLastProcessing" => Ok(Field::CountryOfLastProcessing),
5188						b"depth" => Ok(Field::Depth),
5189						b"gtin" => Ok(Field::Gtin),
5190						b"gtin12" => Ok(Field::Gtin12),
5191						b"gtin13" => Ok(Field::Gtin13),
5192						b"gtin14" => Ok(Field::Gtin14),
5193						b"gtin8" => Ok(Field::Gtin8),
5194						b"hasAdultConsideration" => Ok(Field::HasAdultConsideration),
5195						b"hasEnergyConsumptionDetails" => Ok(Field::HasEnergyConsumptionDetails),
5196						b"hasMeasurement" => Ok(Field::HasMeasurement),
5197						b"hasMerchantReturnPolicy" => Ok(Field::HasMerchantReturnPolicy),
5198						b"hasProductReturnPolicy" => Ok(Field::HasProductReturnPolicy),
5199						b"height" => Ok(Field::Height),
5200						b"inProductGroupWithID" => Ok(Field::InProductGroupWithId),
5201						b"isAccessoryOrSparePartFor" => Ok(Field::IsAccessoryOrSparePartFor),
5202						b"isConsumableFor" => Ok(Field::IsConsumableFor),
5203						b"isRelatedTo" => Ok(Field::IsRelatedTo),
5204						b"isSimilarTo" => Ok(Field::IsSimilarTo),
5205						b"isVariantOf" => Ok(Field::IsVariantOf),
5206						b"itemCondition" => Ok(Field::ItemCondition),
5207						b"logo" => Ok(Field::Logo),
5208						b"manufacturer" => Ok(Field::Manufacturer),
5209						b"mobileUrl" => Ok(Field::MobileUrl),
5210						b"model" => Ok(Field::Model),
5211						b"mpn" => Ok(Field::Mpn),
5212						b"negativeNotes" => Ok(Field::NegativeNotes),
5213						b"nsn" => Ok(Field::Nsn),
5214						b"positiveNotes" => Ok(Field::PositiveNotes),
5215						b"productID" => Ok(Field::ProductId),
5216						b"productionDate" => Ok(Field::ProductionDate),
5217						b"purchaseDate" => Ok(Field::PurchaseDate),
5218						b"releaseDate" => Ok(Field::ReleaseDate),
5219						b"sku" => Ok(Field::Sku),
5220						b"slogan" => Ok(Field::Slogan),
5221						b"weight" => Ok(Field::Weight),
5222						b"width" => Ok(Field::Width),
5223						b"additionalType" => Ok(Field::AdditionalType),
5224						b"alternateName" => Ok(Field::AlternateName),
5225						b"description" => Ok(Field::Description),
5226						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
5227						b"identifier" => Ok(Field::Identifier),
5228						b"image" => Ok(Field::Image),
5229						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
5230						b"name" => Ok(Field::Name),
5231						b"potentialAction" => Ok(Field::PotentialAction),
5232						b"sameAs" => Ok(Field::SameAs),
5233						b"subjectOf" => Ok(Field::SubjectOf),
5234						b"url" => Ok(Field::Url),
5235						b"id" | b"type" => Ok(Field::Ignore),
5236						_ => {
5237							let value = &String::from_utf8_lossy(value);
5238							Err(de::Error::unknown_field(value, FIELDS))
5239						}
5240					}
5241				}
5242			}
5243			impl<'de> Deserialize<'de> for Field {
5244				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5245				where
5246					D: Deserializer<'de>,
5247				{
5248					deserializer.deserialize_identifier(FieldVisitor)
5249				}
5250			}
5251			struct ClassVisitor;
5252			impl<'de> Visitor<'de> for ClassVisitor {
5253				type Value = ProductCollection;
5254				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
5255					formatter.write_str("schema.org schema ProductCollection")
5256				}
5257				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
5258				where
5259					A: de::MapAccess<'de>,
5260				{
5261					let mut r#includes_object_property = None;
5262					let mut r#collection_size_property = None;
5263					let mut r#about_property = None;
5264					let mut r#abstract_property = None;
5265					let mut r#access_mode_property = None;
5266					let mut r#access_mode_sufficient_property = None;
5267					let mut r#accessibility_api_property = None;
5268					let mut r#accessibility_control_property = None;
5269					let mut r#accessibility_feature_property = None;
5270					let mut r#accessibility_hazard_property = None;
5271					let mut r#accessibility_summary_property = None;
5272					let mut r#accountable_person_property = None;
5273					let mut r#acquire_license_page_property = None;
5274					let mut r#aggregate_rating_property = None;
5275					let mut r#alternative_headline_property = None;
5276					let mut r#archived_at_property = None;
5277					let mut r#assesses_property = None;
5278					let mut r#associated_media_property = None;
5279					let mut r#audience_property = None;
5280					let mut r#audio_property = None;
5281					let mut r#author_property = None;
5282					let mut r#award_property = None;
5283					let mut r#awards_property = None;
5284					let mut r#character_property = None;
5285					let mut r#citation_property = None;
5286					let mut r#comment_property = None;
5287					let mut r#comment_count_property = None;
5288					let mut r#conditions_of_access_property = None;
5289					let mut r#content_location_property = None;
5290					let mut r#content_rating_property = None;
5291					let mut r#content_reference_time_property = None;
5292					let mut r#contributor_property = None;
5293					let mut r#copyright_holder_property = None;
5294					let mut r#copyright_notice_property = None;
5295					let mut r#copyright_year_property = None;
5296					let mut r#correction_property = None;
5297					let mut r#country_of_origin_property = None;
5298					let mut r#creative_work_status_property = None;
5299					let mut r#creator_property = None;
5300					let mut r#credit_text_property = None;
5301					let mut r#date_created_property = None;
5302					let mut r#date_modified_property = None;
5303					let mut r#date_published_property = None;
5304					let mut r#discussion_url_property = None;
5305					let mut r#edit_eidr_property = None;
5306					let mut r#editor_property = None;
5307					let mut r#educational_alignment_property = None;
5308					let mut r#educational_level_property = None;
5309					let mut r#educational_use_property = None;
5310					let mut r#encoding_property = None;
5311					let mut r#encoding_format_property = None;
5312					let mut r#encodings_property = None;
5313					let mut r#example_of_work_property = None;
5314					let mut r#expires_property = None;
5315					let mut r#file_format_property = None;
5316					let mut r#funder_property = None;
5317					let mut r#funding_property = None;
5318					let mut r#genre_property = None;
5319					let mut r#has_part_property = None;
5320					let mut r#headline_property = None;
5321					let mut r#in_language_property = None;
5322					let mut r#interaction_statistic_property = None;
5323					let mut r#interactivity_type_property = None;
5324					let mut r#interpreted_as_claim_property = None;
5325					let mut r#is_accessible_for_free_property = None;
5326					let mut r#is_based_on_property = None;
5327					let mut r#is_based_on_url_property = None;
5328					let mut r#is_family_friendly_property = None;
5329					let mut r#is_part_of_property = None;
5330					let mut r#keywords_property = None;
5331					let mut r#learning_resource_type_property = None;
5332					let mut r#license_property = None;
5333					let mut r#location_created_property = None;
5334					let mut r#main_entity_property = None;
5335					let mut r#maintainer_property = None;
5336					let mut r#material_property = None;
5337					let mut r#material_extent_property = None;
5338					let mut r#mentions_property = None;
5339					let mut r#offers_property = None;
5340					let mut r#pattern_property = None;
5341					let mut r#position_property = None;
5342					let mut r#producer_property = None;
5343					let mut r#provider_property = None;
5344					let mut r#publication_property = None;
5345					let mut r#publisher_property = None;
5346					let mut r#publisher_imprint_property = None;
5347					let mut r#publishing_principles_property = None;
5348					let mut r#recorded_at_property = None;
5349					let mut r#released_event_property = None;
5350					let mut r#review_property = None;
5351					let mut r#reviews_property = None;
5352					let mut r#schema_version_property = None;
5353					let mut r#sd_date_published_property = None;
5354					let mut r#sd_license_property = None;
5355					let mut r#sd_publisher_property = None;
5356					let mut r#size_property = None;
5357					let mut r#source_organization_property = None;
5358					let mut r#spatial_property = None;
5359					let mut r#spatial_coverage_property = None;
5360					let mut r#sponsor_property = None;
5361					let mut r#teaches_property = None;
5362					let mut r#temporal_property = None;
5363					let mut r#temporal_coverage_property = None;
5364					let mut r#text_property = None;
5365					let mut r#thumbnail_property = None;
5366					let mut r#thumbnail_url_property = None;
5367					let mut r#time_required_property = None;
5368					let mut r#translation_of_work_property = None;
5369					let mut r#translator_property = None;
5370					let mut r#typical_age_range_property = None;
5371					let mut r#usage_info_property = None;
5372					let mut r#version_property = None;
5373					let mut r#video_property = None;
5374					let mut r#work_example_property = None;
5375					let mut r#work_translation_property = None;
5376					let mut r#additional_property_property = None;
5377					let mut r#asin_property = None;
5378					let mut r#brand_property = None;
5379					let mut r#category_property = None;
5380					let mut r#color_property = None;
5381					let mut r#country_of_assembly_property = None;
5382					let mut r#country_of_last_processing_property = None;
5383					let mut r#depth_property = None;
5384					let mut r#gtin_property = None;
5385					let mut r#gtin_12_property = None;
5386					let mut r#gtin_13_property = None;
5387					let mut r#gtin_14_property = None;
5388					let mut r#gtin_8_property = None;
5389					let mut r#has_adult_consideration_property = None;
5390					let mut r#has_energy_consumption_details_property = None;
5391					let mut r#has_measurement_property = None;
5392					let mut r#has_merchant_return_policy_property = None;
5393					let mut r#has_product_return_policy_property = None;
5394					let mut r#height_property = None;
5395					let mut r#in_product_group_with_id_property = None;
5396					let mut r#is_accessory_or_spare_part_for_property = None;
5397					let mut r#is_consumable_for_property = None;
5398					let mut r#is_related_to_property = None;
5399					let mut r#is_similar_to_property = None;
5400					let mut r#is_variant_of_property = None;
5401					let mut r#item_condition_property = None;
5402					let mut r#logo_property = None;
5403					let mut r#manufacturer_property = None;
5404					let mut r#mobile_url_property = None;
5405					let mut r#model_property = None;
5406					let mut r#mpn_property = None;
5407					let mut r#negative_notes_property = None;
5408					let mut r#nsn_property = None;
5409					let mut r#positive_notes_property = None;
5410					let mut r#product_id_property = None;
5411					let mut r#production_date_property = None;
5412					let mut r#purchase_date_property = None;
5413					let mut r#release_date_property = None;
5414					let mut r#sku_property = None;
5415					let mut r#slogan_property = None;
5416					let mut r#weight_property = None;
5417					let mut r#width_property = None;
5418					let mut r#additional_type_property = None;
5419					let mut r#alternate_name_property = None;
5420					let mut r#description_property = None;
5421					let mut r#disambiguating_description_property = None;
5422					let mut r#identifier_property = None;
5423					let mut r#image_property = None;
5424					let mut r#main_entity_of_page_property = None;
5425					let mut r#name_property = None;
5426					let mut r#potential_action_property = None;
5427					let mut r#same_as_property = None;
5428					let mut r#subject_of_property = None;
5429					let mut r#url_property = None;
5430					while let Some(key) = map.next_key::<Field>()? {
5431						match key {
5432							Field::IncludesObject => {
5433								if r#includes_object_property.is_some() {
5434									return Err(<A::Error as de::Error>::duplicate_field(
5435										"includesObject",
5436									));
5437								}
5438								r#includes_object_property = Some({
5439									struct DeserializeWith(Vec<IncludesObjectProperty>);
5440									impl<'de> Deserialize<'de> for DeserializeWith {
5441										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5442										where
5443											D: Deserializer<'de>,
5444										{
5445											Ok(DeserializeWith(serde_with::As::<
5446												serde_with::OneOrMany<serde_with::Same>,
5447											>::deserialize(deserializer)?))
5448										}
5449									}
5450									match map.next_value::<DeserializeWith>() {
5451										Ok(deserialize_with) => deserialize_with.0,
5452										Err(err) => {
5453											return Err(err);
5454										}
5455									}
5456								});
5457							}
5458							Field::CollectionSize => {
5459								if r#collection_size_property.is_some() {
5460									return Err(<A::Error as de::Error>::duplicate_field(
5461										"collectionSize",
5462									));
5463								}
5464								r#collection_size_property = Some({
5465									struct DeserializeWith(Vec<CollectionSizeProperty>);
5466									impl<'de> Deserialize<'de> for DeserializeWith {
5467										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5468										where
5469											D: Deserializer<'de>,
5470										{
5471											Ok(DeserializeWith(serde_with::As::<
5472												serde_with::OneOrMany<serde_with::Same>,
5473											>::deserialize(deserializer)?))
5474										}
5475									}
5476									match map.next_value::<DeserializeWith>() {
5477										Ok(deserialize_with) => deserialize_with.0,
5478										Err(err) => {
5479											return Err(err);
5480										}
5481									}
5482								});
5483							}
5484							Field::About => {
5485								if r#about_property.is_some() {
5486									return Err(<A::Error as de::Error>::duplicate_field("about"));
5487								}
5488								r#about_property = Some({
5489									struct DeserializeWith(Vec<AboutProperty>);
5490									impl<'de> Deserialize<'de> for DeserializeWith {
5491										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5492										where
5493											D: Deserializer<'de>,
5494										{
5495											Ok(DeserializeWith(serde_with::As::<
5496												serde_with::OneOrMany<serde_with::Same>,
5497											>::deserialize(deserializer)?))
5498										}
5499									}
5500									match map.next_value::<DeserializeWith>() {
5501										Ok(deserialize_with) => deserialize_with.0,
5502										Err(err) => {
5503											return Err(err);
5504										}
5505									}
5506								});
5507							}
5508							Field::Abstract => {
5509								if r#abstract_property.is_some() {
5510									return Err(<A::Error as de::Error>::duplicate_field(
5511										"abstract",
5512									));
5513								}
5514								r#abstract_property = Some({
5515									struct DeserializeWith(Vec<AbstractProperty>);
5516									impl<'de> Deserialize<'de> for DeserializeWith {
5517										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5518										where
5519											D: Deserializer<'de>,
5520										{
5521											Ok(DeserializeWith(serde_with::As::<
5522												serde_with::OneOrMany<serde_with::Same>,
5523											>::deserialize(deserializer)?))
5524										}
5525									}
5526									match map.next_value::<DeserializeWith>() {
5527										Ok(deserialize_with) => deserialize_with.0,
5528										Err(err) => {
5529											return Err(err);
5530										}
5531									}
5532								});
5533							}
5534							Field::AccessMode => {
5535								if r#access_mode_property.is_some() {
5536									return Err(<A::Error as de::Error>::duplicate_field(
5537										"accessMode",
5538									));
5539								}
5540								r#access_mode_property = Some({
5541									struct DeserializeWith(Vec<AccessModeProperty>);
5542									impl<'de> Deserialize<'de> for DeserializeWith {
5543										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5544										where
5545											D: Deserializer<'de>,
5546										{
5547											Ok(DeserializeWith(serde_with::As::<
5548												serde_with::OneOrMany<serde_with::Same>,
5549											>::deserialize(deserializer)?))
5550										}
5551									}
5552									match map.next_value::<DeserializeWith>() {
5553										Ok(deserialize_with) => deserialize_with.0,
5554										Err(err) => {
5555											return Err(err);
5556										}
5557									}
5558								});
5559							}
5560							Field::AccessModeSufficient => {
5561								if r#access_mode_sufficient_property.is_some() {
5562									return Err(<A::Error as de::Error>::duplicate_field(
5563										"accessModeSufficient",
5564									));
5565								}
5566								r#access_mode_sufficient_property = Some({
5567									struct DeserializeWith(Vec<AccessModeSufficientProperty>);
5568									impl<'de> Deserialize<'de> for DeserializeWith {
5569										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5570										where
5571											D: Deserializer<'de>,
5572										{
5573											Ok(DeserializeWith(serde_with::As::<
5574												serde_with::OneOrMany<serde_with::Same>,
5575											>::deserialize(deserializer)?))
5576										}
5577									}
5578									match map.next_value::<DeserializeWith>() {
5579										Ok(deserialize_with) => deserialize_with.0,
5580										Err(err) => {
5581											return Err(err);
5582										}
5583									}
5584								});
5585							}
5586							Field::AccessibilityApi => {
5587								if r#accessibility_api_property.is_some() {
5588									return Err(<A::Error as de::Error>::duplicate_field(
5589										"accessibilityAPI",
5590									));
5591								}
5592								r#accessibility_api_property = Some({
5593									struct DeserializeWith(Vec<AccessibilityApiProperty>);
5594									impl<'de> Deserialize<'de> for DeserializeWith {
5595										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5596										where
5597											D: Deserializer<'de>,
5598										{
5599											Ok(DeserializeWith(serde_with::As::<
5600												serde_with::OneOrMany<serde_with::Same>,
5601											>::deserialize(deserializer)?))
5602										}
5603									}
5604									match map.next_value::<DeserializeWith>() {
5605										Ok(deserialize_with) => deserialize_with.0,
5606										Err(err) => {
5607											return Err(err);
5608										}
5609									}
5610								});
5611							}
5612							Field::AccessibilityControl => {
5613								if r#accessibility_control_property.is_some() {
5614									return Err(<A::Error as de::Error>::duplicate_field(
5615										"accessibilityControl",
5616									));
5617								}
5618								r#accessibility_control_property = Some({
5619									struct DeserializeWith(Vec<AccessibilityControlProperty>);
5620									impl<'de> Deserialize<'de> for DeserializeWith {
5621										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5622										where
5623											D: Deserializer<'de>,
5624										{
5625											Ok(DeserializeWith(serde_with::As::<
5626												serde_with::OneOrMany<serde_with::Same>,
5627											>::deserialize(deserializer)?))
5628										}
5629									}
5630									match map.next_value::<DeserializeWith>() {
5631										Ok(deserialize_with) => deserialize_with.0,
5632										Err(err) => {
5633											return Err(err);
5634										}
5635									}
5636								});
5637							}
5638							Field::AccessibilityFeature => {
5639								if r#accessibility_feature_property.is_some() {
5640									return Err(<A::Error as de::Error>::duplicate_field(
5641										"accessibilityFeature",
5642									));
5643								}
5644								r#accessibility_feature_property = Some({
5645									struct DeserializeWith(Vec<AccessibilityFeatureProperty>);
5646									impl<'de> Deserialize<'de> for DeserializeWith {
5647										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5648										where
5649											D: Deserializer<'de>,
5650										{
5651											Ok(DeserializeWith(serde_with::As::<
5652												serde_with::OneOrMany<serde_with::Same>,
5653											>::deserialize(deserializer)?))
5654										}
5655									}
5656									match map.next_value::<DeserializeWith>() {
5657										Ok(deserialize_with) => deserialize_with.0,
5658										Err(err) => {
5659											return Err(err);
5660										}
5661									}
5662								});
5663							}
5664							Field::AccessibilityHazard => {
5665								if r#accessibility_hazard_property.is_some() {
5666									return Err(<A::Error as de::Error>::duplicate_field(
5667										"accessibilityHazard",
5668									));
5669								}
5670								r#accessibility_hazard_property = Some({
5671									struct DeserializeWith(Vec<AccessibilityHazardProperty>);
5672									impl<'de> Deserialize<'de> for DeserializeWith {
5673										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5674										where
5675											D: Deserializer<'de>,
5676										{
5677											Ok(DeserializeWith(serde_with::As::<
5678												serde_with::OneOrMany<serde_with::Same>,
5679											>::deserialize(deserializer)?))
5680										}
5681									}
5682									match map.next_value::<DeserializeWith>() {
5683										Ok(deserialize_with) => deserialize_with.0,
5684										Err(err) => {
5685											return Err(err);
5686										}
5687									}
5688								});
5689							}
5690							Field::AccessibilitySummary => {
5691								if r#accessibility_summary_property.is_some() {
5692									return Err(<A::Error as de::Error>::duplicate_field(
5693										"accessibilitySummary",
5694									));
5695								}
5696								r#accessibility_summary_property = Some({
5697									struct DeserializeWith(Vec<AccessibilitySummaryProperty>);
5698									impl<'de> Deserialize<'de> for DeserializeWith {
5699										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5700										where
5701											D: Deserializer<'de>,
5702										{
5703											Ok(DeserializeWith(serde_with::As::<
5704												serde_with::OneOrMany<serde_with::Same>,
5705											>::deserialize(deserializer)?))
5706										}
5707									}
5708									match map.next_value::<DeserializeWith>() {
5709										Ok(deserialize_with) => deserialize_with.0,
5710										Err(err) => {
5711											return Err(err);
5712										}
5713									}
5714								});
5715							}
5716							Field::AccountablePerson => {
5717								if r#accountable_person_property.is_some() {
5718									return Err(<A::Error as de::Error>::duplicate_field(
5719										"accountablePerson",
5720									));
5721								}
5722								r#accountable_person_property = Some({
5723									struct DeserializeWith(Vec<AccountablePersonProperty>);
5724									impl<'de> Deserialize<'de> for DeserializeWith {
5725										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5726										where
5727											D: Deserializer<'de>,
5728										{
5729											Ok(DeserializeWith(serde_with::As::<
5730												serde_with::OneOrMany<serde_with::Same>,
5731											>::deserialize(deserializer)?))
5732										}
5733									}
5734									match map.next_value::<DeserializeWith>() {
5735										Ok(deserialize_with) => deserialize_with.0,
5736										Err(err) => {
5737											return Err(err);
5738										}
5739									}
5740								});
5741							}
5742							Field::AcquireLicensePage => {
5743								if r#acquire_license_page_property.is_some() {
5744									return Err(<A::Error as de::Error>::duplicate_field(
5745										"acquireLicensePage",
5746									));
5747								}
5748								r#acquire_license_page_property = Some({
5749									struct DeserializeWith(Vec<AcquireLicensePageProperty>);
5750									impl<'de> Deserialize<'de> for DeserializeWith {
5751										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5752										where
5753											D: Deserializer<'de>,
5754										{
5755											Ok(DeserializeWith(serde_with::As::<
5756												serde_with::OneOrMany<serde_with::Same>,
5757											>::deserialize(deserializer)?))
5758										}
5759									}
5760									match map.next_value::<DeserializeWith>() {
5761										Ok(deserialize_with) => deserialize_with.0,
5762										Err(err) => {
5763											return Err(err);
5764										}
5765									}
5766								});
5767							}
5768							Field::AggregateRating => {
5769								if r#aggregate_rating_property.is_some() {
5770									return Err(<A::Error as de::Error>::duplicate_field(
5771										"aggregateRating",
5772									));
5773								}
5774								r#aggregate_rating_property = Some({
5775									struct DeserializeWith(Vec<AggregateRatingProperty>);
5776									impl<'de> Deserialize<'de> for DeserializeWith {
5777										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5778										where
5779											D: Deserializer<'de>,
5780										{
5781											Ok(DeserializeWith(serde_with::As::<
5782												serde_with::OneOrMany<serde_with::Same>,
5783											>::deserialize(deserializer)?))
5784										}
5785									}
5786									match map.next_value::<DeserializeWith>() {
5787										Ok(deserialize_with) => deserialize_with.0,
5788										Err(err) => {
5789											return Err(err);
5790										}
5791									}
5792								});
5793							}
5794							Field::AlternativeHeadline => {
5795								if r#alternative_headline_property.is_some() {
5796									return Err(<A::Error as de::Error>::duplicate_field(
5797										"alternativeHeadline",
5798									));
5799								}
5800								r#alternative_headline_property = Some({
5801									struct DeserializeWith(Vec<AlternativeHeadlineProperty>);
5802									impl<'de> Deserialize<'de> for DeserializeWith {
5803										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5804										where
5805											D: Deserializer<'de>,
5806										{
5807											Ok(DeserializeWith(serde_with::As::<
5808												serde_with::OneOrMany<serde_with::Same>,
5809											>::deserialize(deserializer)?))
5810										}
5811									}
5812									match map.next_value::<DeserializeWith>() {
5813										Ok(deserialize_with) => deserialize_with.0,
5814										Err(err) => {
5815											return Err(err);
5816										}
5817									}
5818								});
5819							}
5820							Field::ArchivedAt => {
5821								if r#archived_at_property.is_some() {
5822									return Err(<A::Error as de::Error>::duplicate_field(
5823										"archivedAt",
5824									));
5825								}
5826								r#archived_at_property = Some({
5827									struct DeserializeWith(Vec<ArchivedAtProperty>);
5828									impl<'de> Deserialize<'de> for DeserializeWith {
5829										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5830										where
5831											D: Deserializer<'de>,
5832										{
5833											Ok(DeserializeWith(serde_with::As::<
5834												serde_with::OneOrMany<serde_with::Same>,
5835											>::deserialize(deserializer)?))
5836										}
5837									}
5838									match map.next_value::<DeserializeWith>() {
5839										Ok(deserialize_with) => deserialize_with.0,
5840										Err(err) => {
5841											return Err(err);
5842										}
5843									}
5844								});
5845							}
5846							Field::Assesses => {
5847								if r#assesses_property.is_some() {
5848									return Err(<A::Error as de::Error>::duplicate_field(
5849										"assesses",
5850									));
5851								}
5852								r#assesses_property = Some({
5853									struct DeserializeWith(Vec<AssessesProperty>);
5854									impl<'de> Deserialize<'de> for DeserializeWith {
5855										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5856										where
5857											D: Deserializer<'de>,
5858										{
5859											Ok(DeserializeWith(serde_with::As::<
5860												serde_with::OneOrMany<serde_with::Same>,
5861											>::deserialize(deserializer)?))
5862										}
5863									}
5864									match map.next_value::<DeserializeWith>() {
5865										Ok(deserialize_with) => deserialize_with.0,
5866										Err(err) => {
5867											return Err(err);
5868										}
5869									}
5870								});
5871							}
5872							Field::AssociatedMedia => {
5873								if r#associated_media_property.is_some() {
5874									return Err(<A::Error as de::Error>::duplicate_field(
5875										"associatedMedia",
5876									));
5877								}
5878								r#associated_media_property = Some({
5879									struct DeserializeWith(Vec<AssociatedMediaProperty>);
5880									impl<'de> Deserialize<'de> for DeserializeWith {
5881										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5882										where
5883											D: Deserializer<'de>,
5884										{
5885											Ok(DeserializeWith(serde_with::As::<
5886												serde_with::OneOrMany<serde_with::Same>,
5887											>::deserialize(deserializer)?))
5888										}
5889									}
5890									match map.next_value::<DeserializeWith>() {
5891										Ok(deserialize_with) => deserialize_with.0,
5892										Err(err) => {
5893											return Err(err);
5894										}
5895									}
5896								});
5897							}
5898							Field::Audience => {
5899								if r#audience_property.is_some() {
5900									return Err(<A::Error as de::Error>::duplicate_field(
5901										"audience",
5902									));
5903								}
5904								r#audience_property = Some({
5905									struct DeserializeWith(Vec<AudienceProperty>);
5906									impl<'de> Deserialize<'de> for DeserializeWith {
5907										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5908										where
5909											D: Deserializer<'de>,
5910										{
5911											Ok(DeserializeWith(serde_with::As::<
5912												serde_with::OneOrMany<serde_with::Same>,
5913											>::deserialize(deserializer)?))
5914										}
5915									}
5916									match map.next_value::<DeserializeWith>() {
5917										Ok(deserialize_with) => deserialize_with.0,
5918										Err(err) => {
5919											return Err(err);
5920										}
5921									}
5922								});
5923							}
5924							Field::Audio => {
5925								if r#audio_property.is_some() {
5926									return Err(<A::Error as de::Error>::duplicate_field("audio"));
5927								}
5928								r#audio_property = Some({
5929									struct DeserializeWith(Vec<AudioProperty>);
5930									impl<'de> Deserialize<'de> for DeserializeWith {
5931										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5932										where
5933											D: Deserializer<'de>,
5934										{
5935											Ok(DeserializeWith(serde_with::As::<
5936												serde_with::OneOrMany<serde_with::Same>,
5937											>::deserialize(deserializer)?))
5938										}
5939									}
5940									match map.next_value::<DeserializeWith>() {
5941										Ok(deserialize_with) => deserialize_with.0,
5942										Err(err) => {
5943											return Err(err);
5944										}
5945									}
5946								});
5947							}
5948							Field::Author => {
5949								if r#author_property.is_some() {
5950									return Err(<A::Error as de::Error>::duplicate_field("author"));
5951								}
5952								r#author_property = Some({
5953									struct DeserializeWith(Vec<AuthorProperty>);
5954									impl<'de> Deserialize<'de> for DeserializeWith {
5955										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5956										where
5957											D: Deserializer<'de>,
5958										{
5959											Ok(DeserializeWith(serde_with::As::<
5960												serde_with::OneOrMany<serde_with::Same>,
5961											>::deserialize(deserializer)?))
5962										}
5963									}
5964									match map.next_value::<DeserializeWith>() {
5965										Ok(deserialize_with) => deserialize_with.0,
5966										Err(err) => {
5967											return Err(err);
5968										}
5969									}
5970								});
5971							}
5972							Field::Award => {
5973								if r#award_property.is_some() {
5974									return Err(<A::Error as de::Error>::duplicate_field("award"));
5975								}
5976								r#award_property = Some({
5977									struct DeserializeWith(Vec<AwardProperty>);
5978									impl<'de> Deserialize<'de> for DeserializeWith {
5979										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5980										where
5981											D: Deserializer<'de>,
5982										{
5983											Ok(DeserializeWith(serde_with::As::<
5984												serde_with::OneOrMany<serde_with::Same>,
5985											>::deserialize(deserializer)?))
5986										}
5987									}
5988									match map.next_value::<DeserializeWith>() {
5989										Ok(deserialize_with) => deserialize_with.0,
5990										Err(err) => {
5991											return Err(err);
5992										}
5993									}
5994								});
5995							}
5996							Field::Awards => {
5997								if r#awards_property.is_some() {
5998									return Err(<A::Error as de::Error>::duplicate_field("awards"));
5999								}
6000								r#awards_property = Some({
6001									struct DeserializeWith(Vec<AwardsProperty>);
6002									impl<'de> Deserialize<'de> for DeserializeWith {
6003										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6004										where
6005											D: Deserializer<'de>,
6006										{
6007											Ok(DeserializeWith(serde_with::As::<
6008												serde_with::OneOrMany<serde_with::Same>,
6009											>::deserialize(deserializer)?))
6010										}
6011									}
6012									match map.next_value::<DeserializeWith>() {
6013										Ok(deserialize_with) => deserialize_with.0,
6014										Err(err) => {
6015											return Err(err);
6016										}
6017									}
6018								});
6019							}
6020							Field::Character => {
6021								if r#character_property.is_some() {
6022									return Err(<A::Error as de::Error>::duplicate_field(
6023										"character",
6024									));
6025								}
6026								r#character_property = Some({
6027									struct DeserializeWith(Vec<CharacterProperty>);
6028									impl<'de> Deserialize<'de> for DeserializeWith {
6029										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6030										where
6031											D: Deserializer<'de>,
6032										{
6033											Ok(DeserializeWith(serde_with::As::<
6034												serde_with::OneOrMany<serde_with::Same>,
6035											>::deserialize(deserializer)?))
6036										}
6037									}
6038									match map.next_value::<DeserializeWith>() {
6039										Ok(deserialize_with) => deserialize_with.0,
6040										Err(err) => {
6041											return Err(err);
6042										}
6043									}
6044								});
6045							}
6046							Field::Citation => {
6047								if r#citation_property.is_some() {
6048									return Err(<A::Error as de::Error>::duplicate_field(
6049										"citation",
6050									));
6051								}
6052								r#citation_property = Some({
6053									struct DeserializeWith(Vec<CitationProperty>);
6054									impl<'de> Deserialize<'de> for DeserializeWith {
6055										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6056										where
6057											D: Deserializer<'de>,
6058										{
6059											Ok(DeserializeWith(serde_with::As::<
6060												serde_with::OneOrMany<serde_with::Same>,
6061											>::deserialize(deserializer)?))
6062										}
6063									}
6064									match map.next_value::<DeserializeWith>() {
6065										Ok(deserialize_with) => deserialize_with.0,
6066										Err(err) => {
6067											return Err(err);
6068										}
6069									}
6070								});
6071							}
6072							Field::Comment => {
6073								if r#comment_property.is_some() {
6074									return Err(<A::Error as de::Error>::duplicate_field(
6075										"comment",
6076									));
6077								}
6078								r#comment_property = Some({
6079									struct DeserializeWith(Vec<CommentProperty>);
6080									impl<'de> Deserialize<'de> for DeserializeWith {
6081										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6082										where
6083											D: Deserializer<'de>,
6084										{
6085											Ok(DeserializeWith(serde_with::As::<
6086												serde_with::OneOrMany<serde_with::Same>,
6087											>::deserialize(deserializer)?))
6088										}
6089									}
6090									match map.next_value::<DeserializeWith>() {
6091										Ok(deserialize_with) => deserialize_with.0,
6092										Err(err) => {
6093											return Err(err);
6094										}
6095									}
6096								});
6097							}
6098							Field::CommentCount => {
6099								if r#comment_count_property.is_some() {
6100									return Err(<A::Error as de::Error>::duplicate_field(
6101										"commentCount",
6102									));
6103								}
6104								r#comment_count_property = Some({
6105									struct DeserializeWith(Vec<CommentCountProperty>);
6106									impl<'de> Deserialize<'de> for DeserializeWith {
6107										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6108										where
6109											D: Deserializer<'de>,
6110										{
6111											Ok(DeserializeWith(serde_with::As::<
6112												serde_with::OneOrMany<serde_with::Same>,
6113											>::deserialize(deserializer)?))
6114										}
6115									}
6116									match map.next_value::<DeserializeWith>() {
6117										Ok(deserialize_with) => deserialize_with.0,
6118										Err(err) => {
6119											return Err(err);
6120										}
6121									}
6122								});
6123							}
6124							Field::ConditionsOfAccess => {
6125								if r#conditions_of_access_property.is_some() {
6126									return Err(<A::Error as de::Error>::duplicate_field(
6127										"conditionsOfAccess",
6128									));
6129								}
6130								r#conditions_of_access_property = Some({
6131									struct DeserializeWith(Vec<ConditionsOfAccessProperty>);
6132									impl<'de> Deserialize<'de> for DeserializeWith {
6133										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6134										where
6135											D: Deserializer<'de>,
6136										{
6137											Ok(DeserializeWith(serde_with::As::<
6138												serde_with::OneOrMany<serde_with::Same>,
6139											>::deserialize(deserializer)?))
6140										}
6141									}
6142									match map.next_value::<DeserializeWith>() {
6143										Ok(deserialize_with) => deserialize_with.0,
6144										Err(err) => {
6145											return Err(err);
6146										}
6147									}
6148								});
6149							}
6150							Field::ContentLocation => {
6151								if r#content_location_property.is_some() {
6152									return Err(<A::Error as de::Error>::duplicate_field(
6153										"contentLocation",
6154									));
6155								}
6156								r#content_location_property = Some({
6157									struct DeserializeWith(Vec<ContentLocationProperty>);
6158									impl<'de> Deserialize<'de> for DeserializeWith {
6159										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6160										where
6161											D: Deserializer<'de>,
6162										{
6163											Ok(DeserializeWith(serde_with::As::<
6164												serde_with::OneOrMany<serde_with::Same>,
6165											>::deserialize(deserializer)?))
6166										}
6167									}
6168									match map.next_value::<DeserializeWith>() {
6169										Ok(deserialize_with) => deserialize_with.0,
6170										Err(err) => {
6171											return Err(err);
6172										}
6173									}
6174								});
6175							}
6176							Field::ContentRating => {
6177								if r#content_rating_property.is_some() {
6178									return Err(<A::Error as de::Error>::duplicate_field(
6179										"contentRating",
6180									));
6181								}
6182								r#content_rating_property = Some({
6183									struct DeserializeWith(Vec<ContentRatingProperty>);
6184									impl<'de> Deserialize<'de> for DeserializeWith {
6185										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6186										where
6187											D: Deserializer<'de>,
6188										{
6189											Ok(DeserializeWith(serde_with::As::<
6190												serde_with::OneOrMany<serde_with::Same>,
6191											>::deserialize(deserializer)?))
6192										}
6193									}
6194									match map.next_value::<DeserializeWith>() {
6195										Ok(deserialize_with) => deserialize_with.0,
6196										Err(err) => {
6197											return Err(err);
6198										}
6199									}
6200								});
6201							}
6202							Field::ContentReferenceTime => {
6203								if r#content_reference_time_property.is_some() {
6204									return Err(<A::Error as de::Error>::duplicate_field(
6205										"contentReferenceTime",
6206									));
6207								}
6208								r#content_reference_time_property = Some({
6209									struct DeserializeWith(Vec<ContentReferenceTimeProperty>);
6210									impl<'de> Deserialize<'de> for DeserializeWith {
6211										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6212										where
6213											D: Deserializer<'de>,
6214										{
6215											Ok(DeserializeWith(serde_with::As::<
6216												serde_with::OneOrMany<serde_with::Same>,
6217											>::deserialize(deserializer)?))
6218										}
6219									}
6220									match map.next_value::<DeserializeWith>() {
6221										Ok(deserialize_with) => deserialize_with.0,
6222										Err(err) => {
6223											return Err(err);
6224										}
6225									}
6226								});
6227							}
6228							Field::Contributor => {
6229								if r#contributor_property.is_some() {
6230									return Err(<A::Error as de::Error>::duplicate_field(
6231										"contributor",
6232									));
6233								}
6234								r#contributor_property = Some({
6235									struct DeserializeWith(Vec<ContributorProperty>);
6236									impl<'de> Deserialize<'de> for DeserializeWith {
6237										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6238										where
6239											D: Deserializer<'de>,
6240										{
6241											Ok(DeserializeWith(serde_with::As::<
6242												serde_with::OneOrMany<serde_with::Same>,
6243											>::deserialize(deserializer)?))
6244										}
6245									}
6246									match map.next_value::<DeserializeWith>() {
6247										Ok(deserialize_with) => deserialize_with.0,
6248										Err(err) => {
6249											return Err(err);
6250										}
6251									}
6252								});
6253							}
6254							Field::CopyrightHolder => {
6255								if r#copyright_holder_property.is_some() {
6256									return Err(<A::Error as de::Error>::duplicate_field(
6257										"copyrightHolder",
6258									));
6259								}
6260								r#copyright_holder_property = Some({
6261									struct DeserializeWith(Vec<CopyrightHolderProperty>);
6262									impl<'de> Deserialize<'de> for DeserializeWith {
6263										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6264										where
6265											D: Deserializer<'de>,
6266										{
6267											Ok(DeserializeWith(serde_with::As::<
6268												serde_with::OneOrMany<serde_with::Same>,
6269											>::deserialize(deserializer)?))
6270										}
6271									}
6272									match map.next_value::<DeserializeWith>() {
6273										Ok(deserialize_with) => deserialize_with.0,
6274										Err(err) => {
6275											return Err(err);
6276										}
6277									}
6278								});
6279							}
6280							Field::CopyrightNotice => {
6281								if r#copyright_notice_property.is_some() {
6282									return Err(<A::Error as de::Error>::duplicate_field(
6283										"copyrightNotice",
6284									));
6285								}
6286								r#copyright_notice_property = Some({
6287									struct DeserializeWith(Vec<CopyrightNoticeProperty>);
6288									impl<'de> Deserialize<'de> for DeserializeWith {
6289										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6290										where
6291											D: Deserializer<'de>,
6292										{
6293											Ok(DeserializeWith(serde_with::As::<
6294												serde_with::OneOrMany<serde_with::Same>,
6295											>::deserialize(deserializer)?))
6296										}
6297									}
6298									match map.next_value::<DeserializeWith>() {
6299										Ok(deserialize_with) => deserialize_with.0,
6300										Err(err) => {
6301											return Err(err);
6302										}
6303									}
6304								});
6305							}
6306							Field::CopyrightYear => {
6307								if r#copyright_year_property.is_some() {
6308									return Err(<A::Error as de::Error>::duplicate_field(
6309										"copyrightYear",
6310									));
6311								}
6312								r#copyright_year_property = Some({
6313									struct DeserializeWith(Vec<CopyrightYearProperty>);
6314									impl<'de> Deserialize<'de> for DeserializeWith {
6315										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6316										where
6317											D: Deserializer<'de>,
6318										{
6319											Ok(DeserializeWith(serde_with::As::<
6320												serde_with::OneOrMany<serde_with::Same>,
6321											>::deserialize(deserializer)?))
6322										}
6323									}
6324									match map.next_value::<DeserializeWith>() {
6325										Ok(deserialize_with) => deserialize_with.0,
6326										Err(err) => {
6327											return Err(err);
6328										}
6329									}
6330								});
6331							}
6332							Field::Correction => {
6333								if r#correction_property.is_some() {
6334									return Err(<A::Error as de::Error>::duplicate_field(
6335										"correction",
6336									));
6337								}
6338								r#correction_property = Some({
6339									struct DeserializeWith(Vec<CorrectionProperty>);
6340									impl<'de> Deserialize<'de> for DeserializeWith {
6341										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6342										where
6343											D: Deserializer<'de>,
6344										{
6345											Ok(DeserializeWith(serde_with::As::<
6346												serde_with::OneOrMany<serde_with::Same>,
6347											>::deserialize(deserializer)?))
6348										}
6349									}
6350									match map.next_value::<DeserializeWith>() {
6351										Ok(deserialize_with) => deserialize_with.0,
6352										Err(err) => {
6353											return Err(err);
6354										}
6355									}
6356								});
6357							}
6358							Field::CountryOfOrigin => {
6359								if r#country_of_origin_property.is_some() {
6360									return Err(<A::Error as de::Error>::duplicate_field(
6361										"countryOfOrigin",
6362									));
6363								}
6364								r#country_of_origin_property = Some({
6365									struct DeserializeWith(Vec<CountryOfOriginProperty>);
6366									impl<'de> Deserialize<'de> for DeserializeWith {
6367										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6368										where
6369											D: Deserializer<'de>,
6370										{
6371											Ok(DeserializeWith(serde_with::As::<
6372												serde_with::OneOrMany<serde_with::Same>,
6373											>::deserialize(deserializer)?))
6374										}
6375									}
6376									match map.next_value::<DeserializeWith>() {
6377										Ok(deserialize_with) => deserialize_with.0,
6378										Err(err) => {
6379											return Err(err);
6380										}
6381									}
6382								});
6383							}
6384							Field::CreativeWorkStatus => {
6385								if r#creative_work_status_property.is_some() {
6386									return Err(<A::Error as de::Error>::duplicate_field(
6387										"creativeWorkStatus",
6388									));
6389								}
6390								r#creative_work_status_property = Some({
6391									struct DeserializeWith(Vec<CreativeWorkStatusProperty>);
6392									impl<'de> Deserialize<'de> for DeserializeWith {
6393										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6394										where
6395											D: Deserializer<'de>,
6396										{
6397											Ok(DeserializeWith(serde_with::As::<
6398												serde_with::OneOrMany<serde_with::Same>,
6399											>::deserialize(deserializer)?))
6400										}
6401									}
6402									match map.next_value::<DeserializeWith>() {
6403										Ok(deserialize_with) => deserialize_with.0,
6404										Err(err) => {
6405											return Err(err);
6406										}
6407									}
6408								});
6409							}
6410							Field::Creator => {
6411								if r#creator_property.is_some() {
6412									return Err(<A::Error as de::Error>::duplicate_field(
6413										"creator",
6414									));
6415								}
6416								r#creator_property = Some({
6417									struct DeserializeWith(Vec<CreatorProperty>);
6418									impl<'de> Deserialize<'de> for DeserializeWith {
6419										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6420										where
6421											D: Deserializer<'de>,
6422										{
6423											Ok(DeserializeWith(serde_with::As::<
6424												serde_with::OneOrMany<serde_with::Same>,
6425											>::deserialize(deserializer)?))
6426										}
6427									}
6428									match map.next_value::<DeserializeWith>() {
6429										Ok(deserialize_with) => deserialize_with.0,
6430										Err(err) => {
6431											return Err(err);
6432										}
6433									}
6434								});
6435							}
6436							Field::CreditText => {
6437								if r#credit_text_property.is_some() {
6438									return Err(<A::Error as de::Error>::duplicate_field(
6439										"creditText",
6440									));
6441								}
6442								r#credit_text_property = Some({
6443									struct DeserializeWith(Vec<CreditTextProperty>);
6444									impl<'de> Deserialize<'de> for DeserializeWith {
6445										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6446										where
6447											D: Deserializer<'de>,
6448										{
6449											Ok(DeserializeWith(serde_with::As::<
6450												serde_with::OneOrMany<serde_with::Same>,
6451											>::deserialize(deserializer)?))
6452										}
6453									}
6454									match map.next_value::<DeserializeWith>() {
6455										Ok(deserialize_with) => deserialize_with.0,
6456										Err(err) => {
6457											return Err(err);
6458										}
6459									}
6460								});
6461							}
6462							Field::DateCreated => {
6463								if r#date_created_property.is_some() {
6464									return Err(<A::Error as de::Error>::duplicate_field(
6465										"dateCreated",
6466									));
6467								}
6468								r#date_created_property = Some({
6469									struct DeserializeWith(Vec<DateCreatedProperty>);
6470									impl<'de> Deserialize<'de> for DeserializeWith {
6471										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6472										where
6473											D: Deserializer<'de>,
6474										{
6475											Ok(DeserializeWith(serde_with::As::<
6476												serde_with::OneOrMany<serde_with::Same>,
6477											>::deserialize(deserializer)?))
6478										}
6479									}
6480									match map.next_value::<DeserializeWith>() {
6481										Ok(deserialize_with) => deserialize_with.0,
6482										Err(err) => {
6483											return Err(err);
6484										}
6485									}
6486								});
6487							}
6488							Field::DateModified => {
6489								if r#date_modified_property.is_some() {
6490									return Err(<A::Error as de::Error>::duplicate_field(
6491										"dateModified",
6492									));
6493								}
6494								r#date_modified_property = Some({
6495									struct DeserializeWith(Vec<DateModifiedProperty>);
6496									impl<'de> Deserialize<'de> for DeserializeWith {
6497										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6498										where
6499											D: Deserializer<'de>,
6500										{
6501											Ok(DeserializeWith(serde_with::As::<
6502												serde_with::OneOrMany<serde_with::Same>,
6503											>::deserialize(deserializer)?))
6504										}
6505									}
6506									match map.next_value::<DeserializeWith>() {
6507										Ok(deserialize_with) => deserialize_with.0,
6508										Err(err) => {
6509											return Err(err);
6510										}
6511									}
6512								});
6513							}
6514							Field::DatePublished => {
6515								if r#date_published_property.is_some() {
6516									return Err(<A::Error as de::Error>::duplicate_field(
6517										"datePublished",
6518									));
6519								}
6520								r#date_published_property = Some({
6521									struct DeserializeWith(Vec<DatePublishedProperty>);
6522									impl<'de> Deserialize<'de> for DeserializeWith {
6523										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6524										where
6525											D: Deserializer<'de>,
6526										{
6527											Ok(DeserializeWith(serde_with::As::<
6528												serde_with::OneOrMany<serde_with::Same>,
6529											>::deserialize(deserializer)?))
6530										}
6531									}
6532									match map.next_value::<DeserializeWith>() {
6533										Ok(deserialize_with) => deserialize_with.0,
6534										Err(err) => {
6535											return Err(err);
6536										}
6537									}
6538								});
6539							}
6540							Field::DiscussionUrl => {
6541								if r#discussion_url_property.is_some() {
6542									return Err(<A::Error as de::Error>::duplicate_field(
6543										"discussionUrl",
6544									));
6545								}
6546								r#discussion_url_property = Some({
6547									struct DeserializeWith(Vec<DiscussionUrlProperty>);
6548									impl<'de> Deserialize<'de> for DeserializeWith {
6549										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6550										where
6551											D: Deserializer<'de>,
6552										{
6553											Ok(DeserializeWith(serde_with::As::<
6554												serde_with::OneOrMany<serde_with::Same>,
6555											>::deserialize(deserializer)?))
6556										}
6557									}
6558									match map.next_value::<DeserializeWith>() {
6559										Ok(deserialize_with) => deserialize_with.0,
6560										Err(err) => {
6561											return Err(err);
6562										}
6563									}
6564								});
6565							}
6566							Field::EditEidr => {
6567								if r#edit_eidr_property.is_some() {
6568									return Err(<A::Error as de::Error>::duplicate_field(
6569										"editEIDR",
6570									));
6571								}
6572								r#edit_eidr_property = Some({
6573									struct DeserializeWith(Vec<EditEidrProperty>);
6574									impl<'de> Deserialize<'de> for DeserializeWith {
6575										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6576										where
6577											D: Deserializer<'de>,
6578										{
6579											Ok(DeserializeWith(serde_with::As::<
6580												serde_with::OneOrMany<serde_with::Same>,
6581											>::deserialize(deserializer)?))
6582										}
6583									}
6584									match map.next_value::<DeserializeWith>() {
6585										Ok(deserialize_with) => deserialize_with.0,
6586										Err(err) => {
6587											return Err(err);
6588										}
6589									}
6590								});
6591							}
6592							Field::Editor => {
6593								if r#editor_property.is_some() {
6594									return Err(<A::Error as de::Error>::duplicate_field("editor"));
6595								}
6596								r#editor_property = Some({
6597									struct DeserializeWith(Vec<EditorProperty>);
6598									impl<'de> Deserialize<'de> for DeserializeWith {
6599										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6600										where
6601											D: Deserializer<'de>,
6602										{
6603											Ok(DeserializeWith(serde_with::As::<
6604												serde_with::OneOrMany<serde_with::Same>,
6605											>::deserialize(deserializer)?))
6606										}
6607									}
6608									match map.next_value::<DeserializeWith>() {
6609										Ok(deserialize_with) => deserialize_with.0,
6610										Err(err) => {
6611											return Err(err);
6612										}
6613									}
6614								});
6615							}
6616							Field::EducationalAlignment => {
6617								if r#educational_alignment_property.is_some() {
6618									return Err(<A::Error as de::Error>::duplicate_field(
6619										"educationalAlignment",
6620									));
6621								}
6622								r#educational_alignment_property = Some({
6623									struct DeserializeWith(Vec<EducationalAlignmentProperty>);
6624									impl<'de> Deserialize<'de> for DeserializeWith {
6625										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6626										where
6627											D: Deserializer<'de>,
6628										{
6629											Ok(DeserializeWith(serde_with::As::<
6630												serde_with::OneOrMany<serde_with::Same>,
6631											>::deserialize(deserializer)?))
6632										}
6633									}
6634									match map.next_value::<DeserializeWith>() {
6635										Ok(deserialize_with) => deserialize_with.0,
6636										Err(err) => {
6637											return Err(err);
6638										}
6639									}
6640								});
6641							}
6642							Field::EducationalLevel => {
6643								if r#educational_level_property.is_some() {
6644									return Err(<A::Error as de::Error>::duplicate_field(
6645										"educationalLevel",
6646									));
6647								}
6648								r#educational_level_property = Some({
6649									struct DeserializeWith(Vec<EducationalLevelProperty>);
6650									impl<'de> Deserialize<'de> for DeserializeWith {
6651										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6652										where
6653											D: Deserializer<'de>,
6654										{
6655											Ok(DeserializeWith(serde_with::As::<
6656												serde_with::OneOrMany<serde_with::Same>,
6657											>::deserialize(deserializer)?))
6658										}
6659									}
6660									match map.next_value::<DeserializeWith>() {
6661										Ok(deserialize_with) => deserialize_with.0,
6662										Err(err) => {
6663											return Err(err);
6664										}
6665									}
6666								});
6667							}
6668							Field::EducationalUse => {
6669								if r#educational_use_property.is_some() {
6670									return Err(<A::Error as de::Error>::duplicate_field(
6671										"educationalUse",
6672									));
6673								}
6674								r#educational_use_property = Some({
6675									struct DeserializeWith(Vec<EducationalUseProperty>);
6676									impl<'de> Deserialize<'de> for DeserializeWith {
6677										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6678										where
6679											D: Deserializer<'de>,
6680										{
6681											Ok(DeserializeWith(serde_with::As::<
6682												serde_with::OneOrMany<serde_with::Same>,
6683											>::deserialize(deserializer)?))
6684										}
6685									}
6686									match map.next_value::<DeserializeWith>() {
6687										Ok(deserialize_with) => deserialize_with.0,
6688										Err(err) => {
6689											return Err(err);
6690										}
6691									}
6692								});
6693							}
6694							Field::Encoding => {
6695								if r#encoding_property.is_some() {
6696									return Err(<A::Error as de::Error>::duplicate_field(
6697										"encoding",
6698									));
6699								}
6700								r#encoding_property = Some({
6701									struct DeserializeWith(Vec<EncodingProperty>);
6702									impl<'de> Deserialize<'de> for DeserializeWith {
6703										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6704										where
6705											D: Deserializer<'de>,
6706										{
6707											Ok(DeserializeWith(serde_with::As::<
6708												serde_with::OneOrMany<serde_with::Same>,
6709											>::deserialize(deserializer)?))
6710										}
6711									}
6712									match map.next_value::<DeserializeWith>() {
6713										Ok(deserialize_with) => deserialize_with.0,
6714										Err(err) => {
6715											return Err(err);
6716										}
6717									}
6718								});
6719							}
6720							Field::EncodingFormat => {
6721								if r#encoding_format_property.is_some() {
6722									return Err(<A::Error as de::Error>::duplicate_field(
6723										"encodingFormat",
6724									));
6725								}
6726								r#encoding_format_property = Some({
6727									struct DeserializeWith(Vec<EncodingFormatProperty>);
6728									impl<'de> Deserialize<'de> for DeserializeWith {
6729										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6730										where
6731											D: Deserializer<'de>,
6732										{
6733											Ok(DeserializeWith(serde_with::As::<
6734												serde_with::OneOrMany<serde_with::Same>,
6735											>::deserialize(deserializer)?))
6736										}
6737									}
6738									match map.next_value::<DeserializeWith>() {
6739										Ok(deserialize_with) => deserialize_with.0,
6740										Err(err) => {
6741											return Err(err);
6742										}
6743									}
6744								});
6745							}
6746							Field::Encodings => {
6747								if r#encodings_property.is_some() {
6748									return Err(<A::Error as de::Error>::duplicate_field(
6749										"encodings",
6750									));
6751								}
6752								r#encodings_property = Some({
6753									struct DeserializeWith(Vec<EncodingsProperty>);
6754									impl<'de> Deserialize<'de> for DeserializeWith {
6755										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6756										where
6757											D: Deserializer<'de>,
6758										{
6759											Ok(DeserializeWith(serde_with::As::<
6760												serde_with::OneOrMany<serde_with::Same>,
6761											>::deserialize(deserializer)?))
6762										}
6763									}
6764									match map.next_value::<DeserializeWith>() {
6765										Ok(deserialize_with) => deserialize_with.0,
6766										Err(err) => {
6767											return Err(err);
6768										}
6769									}
6770								});
6771							}
6772							Field::ExampleOfWork => {
6773								if r#example_of_work_property.is_some() {
6774									return Err(<A::Error as de::Error>::duplicate_field(
6775										"exampleOfWork",
6776									));
6777								}
6778								r#example_of_work_property = Some({
6779									struct DeserializeWith(Vec<ExampleOfWorkProperty>);
6780									impl<'de> Deserialize<'de> for DeserializeWith {
6781										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6782										where
6783											D: Deserializer<'de>,
6784										{
6785											Ok(DeserializeWith(serde_with::As::<
6786												serde_with::OneOrMany<serde_with::Same>,
6787											>::deserialize(deserializer)?))
6788										}
6789									}
6790									match map.next_value::<DeserializeWith>() {
6791										Ok(deserialize_with) => deserialize_with.0,
6792										Err(err) => {
6793											return Err(err);
6794										}
6795									}
6796								});
6797							}
6798							Field::Expires => {
6799								if r#expires_property.is_some() {
6800									return Err(<A::Error as de::Error>::duplicate_field(
6801										"expires",
6802									));
6803								}
6804								r#expires_property = Some({
6805									struct DeserializeWith(Vec<ExpiresProperty>);
6806									impl<'de> Deserialize<'de> for DeserializeWith {
6807										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6808										where
6809											D: Deserializer<'de>,
6810										{
6811											Ok(DeserializeWith(serde_with::As::<
6812												serde_with::OneOrMany<serde_with::Same>,
6813											>::deserialize(deserializer)?))
6814										}
6815									}
6816									match map.next_value::<DeserializeWith>() {
6817										Ok(deserialize_with) => deserialize_with.0,
6818										Err(err) => {
6819											return Err(err);
6820										}
6821									}
6822								});
6823							}
6824							Field::FileFormat => {
6825								if r#file_format_property.is_some() {
6826									return Err(<A::Error as de::Error>::duplicate_field(
6827										"fileFormat",
6828									));
6829								}
6830								r#file_format_property = Some({
6831									struct DeserializeWith(Vec<FileFormatProperty>);
6832									impl<'de> Deserialize<'de> for DeserializeWith {
6833										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6834										where
6835											D: Deserializer<'de>,
6836										{
6837											Ok(DeserializeWith(serde_with::As::<
6838												serde_with::OneOrMany<serde_with::Same>,
6839											>::deserialize(deserializer)?))
6840										}
6841									}
6842									match map.next_value::<DeserializeWith>() {
6843										Ok(deserialize_with) => deserialize_with.0,
6844										Err(err) => {
6845											return Err(err);
6846										}
6847									}
6848								});
6849							}
6850							Field::Funder => {
6851								if r#funder_property.is_some() {
6852									return Err(<A::Error as de::Error>::duplicate_field("funder"));
6853								}
6854								r#funder_property = Some({
6855									struct DeserializeWith(Vec<FunderProperty>);
6856									impl<'de> Deserialize<'de> for DeserializeWith {
6857										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6858										where
6859											D: Deserializer<'de>,
6860										{
6861											Ok(DeserializeWith(serde_with::As::<
6862												serde_with::OneOrMany<serde_with::Same>,
6863											>::deserialize(deserializer)?))
6864										}
6865									}
6866									match map.next_value::<DeserializeWith>() {
6867										Ok(deserialize_with) => deserialize_with.0,
6868										Err(err) => {
6869											return Err(err);
6870										}
6871									}
6872								});
6873							}
6874							Field::Funding => {
6875								if r#funding_property.is_some() {
6876									return Err(<A::Error as de::Error>::duplicate_field(
6877										"funding",
6878									));
6879								}
6880								r#funding_property = Some({
6881									struct DeserializeWith(Vec<FundingProperty>);
6882									impl<'de> Deserialize<'de> for DeserializeWith {
6883										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6884										where
6885											D: Deserializer<'de>,
6886										{
6887											Ok(DeserializeWith(serde_with::As::<
6888												serde_with::OneOrMany<serde_with::Same>,
6889											>::deserialize(deserializer)?))
6890										}
6891									}
6892									match map.next_value::<DeserializeWith>() {
6893										Ok(deserialize_with) => deserialize_with.0,
6894										Err(err) => {
6895											return Err(err);
6896										}
6897									}
6898								});
6899							}
6900							Field::Genre => {
6901								if r#genre_property.is_some() {
6902									return Err(<A::Error as de::Error>::duplicate_field("genre"));
6903								}
6904								r#genre_property = Some({
6905									struct DeserializeWith(Vec<GenreProperty>);
6906									impl<'de> Deserialize<'de> for DeserializeWith {
6907										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6908										where
6909											D: Deserializer<'de>,
6910										{
6911											Ok(DeserializeWith(serde_with::As::<
6912												serde_with::OneOrMany<serde_with::Same>,
6913											>::deserialize(deserializer)?))
6914										}
6915									}
6916									match map.next_value::<DeserializeWith>() {
6917										Ok(deserialize_with) => deserialize_with.0,
6918										Err(err) => {
6919											return Err(err);
6920										}
6921									}
6922								});
6923							}
6924							Field::HasPart => {
6925								if r#has_part_property.is_some() {
6926									return Err(<A::Error as de::Error>::duplicate_field(
6927										"hasPart",
6928									));
6929								}
6930								r#has_part_property = Some({
6931									struct DeserializeWith(Vec<HasPartProperty>);
6932									impl<'de> Deserialize<'de> for DeserializeWith {
6933										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6934										where
6935											D: Deserializer<'de>,
6936										{
6937											Ok(DeserializeWith(serde_with::As::<
6938												serde_with::OneOrMany<serde_with::Same>,
6939											>::deserialize(deserializer)?))
6940										}
6941									}
6942									match map.next_value::<DeserializeWith>() {
6943										Ok(deserialize_with) => deserialize_with.0,
6944										Err(err) => {
6945											return Err(err);
6946										}
6947									}
6948								});
6949							}
6950							Field::Headline => {
6951								if r#headline_property.is_some() {
6952									return Err(<A::Error as de::Error>::duplicate_field(
6953										"headline",
6954									));
6955								}
6956								r#headline_property = Some({
6957									struct DeserializeWith(Vec<HeadlineProperty>);
6958									impl<'de> Deserialize<'de> for DeserializeWith {
6959										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6960										where
6961											D: Deserializer<'de>,
6962										{
6963											Ok(DeserializeWith(serde_with::As::<
6964												serde_with::OneOrMany<serde_with::Same>,
6965											>::deserialize(deserializer)?))
6966										}
6967									}
6968									match map.next_value::<DeserializeWith>() {
6969										Ok(deserialize_with) => deserialize_with.0,
6970										Err(err) => {
6971											return Err(err);
6972										}
6973									}
6974								});
6975							}
6976							Field::InLanguage => {
6977								if r#in_language_property.is_some() {
6978									return Err(<A::Error as de::Error>::duplicate_field(
6979										"inLanguage",
6980									));
6981								}
6982								r#in_language_property = Some({
6983									struct DeserializeWith(Vec<InLanguageProperty>);
6984									impl<'de> Deserialize<'de> for DeserializeWith {
6985										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6986										where
6987											D: Deserializer<'de>,
6988										{
6989											Ok(DeserializeWith(serde_with::As::<
6990												serde_with::OneOrMany<serde_with::Same>,
6991											>::deserialize(deserializer)?))
6992										}
6993									}
6994									match map.next_value::<DeserializeWith>() {
6995										Ok(deserialize_with) => deserialize_with.0,
6996										Err(err) => {
6997											return Err(err);
6998										}
6999									}
7000								});
7001							}
7002							Field::InteractionStatistic => {
7003								if r#interaction_statistic_property.is_some() {
7004									return Err(<A::Error as de::Error>::duplicate_field(
7005										"interactionStatistic",
7006									));
7007								}
7008								r#interaction_statistic_property = Some({
7009									struct DeserializeWith(Vec<InteractionStatisticProperty>);
7010									impl<'de> Deserialize<'de> for DeserializeWith {
7011										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7012										where
7013											D: Deserializer<'de>,
7014										{
7015											Ok(DeserializeWith(serde_with::As::<
7016												serde_with::OneOrMany<serde_with::Same>,
7017											>::deserialize(deserializer)?))
7018										}
7019									}
7020									match map.next_value::<DeserializeWith>() {
7021										Ok(deserialize_with) => deserialize_with.0,
7022										Err(err) => {
7023											return Err(err);
7024										}
7025									}
7026								});
7027							}
7028							Field::InteractivityType => {
7029								if r#interactivity_type_property.is_some() {
7030									return Err(<A::Error as de::Error>::duplicate_field(
7031										"interactivityType",
7032									));
7033								}
7034								r#interactivity_type_property = Some({
7035									struct DeserializeWith(Vec<InteractivityTypeProperty>);
7036									impl<'de> Deserialize<'de> for DeserializeWith {
7037										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7038										where
7039											D: Deserializer<'de>,
7040										{
7041											Ok(DeserializeWith(serde_with::As::<
7042												serde_with::OneOrMany<serde_with::Same>,
7043											>::deserialize(deserializer)?))
7044										}
7045									}
7046									match map.next_value::<DeserializeWith>() {
7047										Ok(deserialize_with) => deserialize_with.0,
7048										Err(err) => {
7049											return Err(err);
7050										}
7051									}
7052								});
7053							}
7054							Field::InterpretedAsClaim => {
7055								if r#interpreted_as_claim_property.is_some() {
7056									return Err(<A::Error as de::Error>::duplicate_field(
7057										"interpretedAsClaim",
7058									));
7059								}
7060								r#interpreted_as_claim_property = Some({
7061									struct DeserializeWith(Vec<InterpretedAsClaimProperty>);
7062									impl<'de> Deserialize<'de> for DeserializeWith {
7063										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7064										where
7065											D: Deserializer<'de>,
7066										{
7067											Ok(DeserializeWith(serde_with::As::<
7068												serde_with::OneOrMany<serde_with::Same>,
7069											>::deserialize(deserializer)?))
7070										}
7071									}
7072									match map.next_value::<DeserializeWith>() {
7073										Ok(deserialize_with) => deserialize_with.0,
7074										Err(err) => {
7075											return Err(err);
7076										}
7077									}
7078								});
7079							}
7080							Field::IsAccessibleForFree => {
7081								if r#is_accessible_for_free_property.is_some() {
7082									return Err(<A::Error as de::Error>::duplicate_field(
7083										"isAccessibleForFree",
7084									));
7085								}
7086								r#is_accessible_for_free_property = Some({
7087									struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
7088									impl<'de> Deserialize<'de> for DeserializeWith {
7089										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7090										where
7091											D: Deserializer<'de>,
7092										{
7093											Ok(DeserializeWith(serde_with::As::<
7094												serde_with::OneOrMany<serde_with::Same>,
7095											>::deserialize(deserializer)?))
7096										}
7097									}
7098									match map.next_value::<DeserializeWith>() {
7099										Ok(deserialize_with) => deserialize_with.0,
7100										Err(err) => {
7101											return Err(err);
7102										}
7103									}
7104								});
7105							}
7106							Field::IsBasedOn => {
7107								if r#is_based_on_property.is_some() {
7108									return Err(<A::Error as de::Error>::duplicate_field(
7109										"isBasedOn",
7110									));
7111								}
7112								r#is_based_on_property = Some({
7113									struct DeserializeWith(Vec<IsBasedOnProperty>);
7114									impl<'de> Deserialize<'de> for DeserializeWith {
7115										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7116										where
7117											D: Deserializer<'de>,
7118										{
7119											Ok(DeserializeWith(serde_with::As::<
7120												serde_with::OneOrMany<serde_with::Same>,
7121											>::deserialize(deserializer)?))
7122										}
7123									}
7124									match map.next_value::<DeserializeWith>() {
7125										Ok(deserialize_with) => deserialize_with.0,
7126										Err(err) => {
7127											return Err(err);
7128										}
7129									}
7130								});
7131							}
7132							Field::IsBasedOnUrl => {
7133								if r#is_based_on_url_property.is_some() {
7134									return Err(<A::Error as de::Error>::duplicate_field(
7135										"isBasedOnUrl",
7136									));
7137								}
7138								r#is_based_on_url_property = Some({
7139									struct DeserializeWith(Vec<IsBasedOnUrlProperty>);
7140									impl<'de> Deserialize<'de> for DeserializeWith {
7141										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7142										where
7143											D: Deserializer<'de>,
7144										{
7145											Ok(DeserializeWith(serde_with::As::<
7146												serde_with::OneOrMany<serde_with::Same>,
7147											>::deserialize(deserializer)?))
7148										}
7149									}
7150									match map.next_value::<DeserializeWith>() {
7151										Ok(deserialize_with) => deserialize_with.0,
7152										Err(err) => {
7153											return Err(err);
7154										}
7155									}
7156								});
7157							}
7158							Field::IsFamilyFriendly => {
7159								if r#is_family_friendly_property.is_some() {
7160									return Err(<A::Error as de::Error>::duplicate_field(
7161										"isFamilyFriendly",
7162									));
7163								}
7164								r#is_family_friendly_property = Some({
7165									struct DeserializeWith(Vec<IsFamilyFriendlyProperty>);
7166									impl<'de> Deserialize<'de> for DeserializeWith {
7167										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7168										where
7169											D: Deserializer<'de>,
7170										{
7171											Ok(DeserializeWith(serde_with::As::<
7172												serde_with::OneOrMany<serde_with::Same>,
7173											>::deserialize(deserializer)?))
7174										}
7175									}
7176									match map.next_value::<DeserializeWith>() {
7177										Ok(deserialize_with) => deserialize_with.0,
7178										Err(err) => {
7179											return Err(err);
7180										}
7181									}
7182								});
7183							}
7184							Field::IsPartOf => {
7185								if r#is_part_of_property.is_some() {
7186									return Err(<A::Error as de::Error>::duplicate_field(
7187										"isPartOf",
7188									));
7189								}
7190								r#is_part_of_property = Some({
7191									struct DeserializeWith(Vec<IsPartOfProperty>);
7192									impl<'de> Deserialize<'de> for DeserializeWith {
7193										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7194										where
7195											D: Deserializer<'de>,
7196										{
7197											Ok(DeserializeWith(serde_with::As::<
7198												serde_with::OneOrMany<serde_with::Same>,
7199											>::deserialize(deserializer)?))
7200										}
7201									}
7202									match map.next_value::<DeserializeWith>() {
7203										Ok(deserialize_with) => deserialize_with.0,
7204										Err(err) => {
7205											return Err(err);
7206										}
7207									}
7208								});
7209							}
7210							Field::Keywords => {
7211								if r#keywords_property.is_some() {
7212									return Err(<A::Error as de::Error>::duplicate_field(
7213										"keywords",
7214									));
7215								}
7216								r#keywords_property = Some({
7217									struct DeserializeWith(Vec<KeywordsProperty>);
7218									impl<'de> Deserialize<'de> for DeserializeWith {
7219										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7220										where
7221											D: Deserializer<'de>,
7222										{
7223											Ok(DeserializeWith(serde_with::As::<
7224												serde_with::OneOrMany<serde_with::Same>,
7225											>::deserialize(deserializer)?))
7226										}
7227									}
7228									match map.next_value::<DeserializeWith>() {
7229										Ok(deserialize_with) => deserialize_with.0,
7230										Err(err) => {
7231											return Err(err);
7232										}
7233									}
7234								});
7235							}
7236							Field::LearningResourceType => {
7237								if r#learning_resource_type_property.is_some() {
7238									return Err(<A::Error as de::Error>::duplicate_field(
7239										"learningResourceType",
7240									));
7241								}
7242								r#learning_resource_type_property = Some({
7243									struct DeserializeWith(Vec<LearningResourceTypeProperty>);
7244									impl<'de> Deserialize<'de> for DeserializeWith {
7245										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7246										where
7247											D: Deserializer<'de>,
7248										{
7249											Ok(DeserializeWith(serde_with::As::<
7250												serde_with::OneOrMany<serde_with::Same>,
7251											>::deserialize(deserializer)?))
7252										}
7253									}
7254									match map.next_value::<DeserializeWith>() {
7255										Ok(deserialize_with) => deserialize_with.0,
7256										Err(err) => {
7257											return Err(err);
7258										}
7259									}
7260								});
7261							}
7262							Field::License => {
7263								if r#license_property.is_some() {
7264									return Err(<A::Error as de::Error>::duplicate_field(
7265										"license",
7266									));
7267								}
7268								r#license_property = Some({
7269									struct DeserializeWith(Vec<LicenseProperty>);
7270									impl<'de> Deserialize<'de> for DeserializeWith {
7271										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7272										where
7273											D: Deserializer<'de>,
7274										{
7275											Ok(DeserializeWith(serde_with::As::<
7276												serde_with::OneOrMany<serde_with::Same>,
7277											>::deserialize(deserializer)?))
7278										}
7279									}
7280									match map.next_value::<DeserializeWith>() {
7281										Ok(deserialize_with) => deserialize_with.0,
7282										Err(err) => {
7283											return Err(err);
7284										}
7285									}
7286								});
7287							}
7288							Field::LocationCreated => {
7289								if r#location_created_property.is_some() {
7290									return Err(<A::Error as de::Error>::duplicate_field(
7291										"locationCreated",
7292									));
7293								}
7294								r#location_created_property = Some({
7295									struct DeserializeWith(Vec<LocationCreatedProperty>);
7296									impl<'de> Deserialize<'de> for DeserializeWith {
7297										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7298										where
7299											D: Deserializer<'de>,
7300										{
7301											Ok(DeserializeWith(serde_with::As::<
7302												serde_with::OneOrMany<serde_with::Same>,
7303											>::deserialize(deserializer)?))
7304										}
7305									}
7306									match map.next_value::<DeserializeWith>() {
7307										Ok(deserialize_with) => deserialize_with.0,
7308										Err(err) => {
7309											return Err(err);
7310										}
7311									}
7312								});
7313							}
7314							Field::MainEntity => {
7315								if r#main_entity_property.is_some() {
7316									return Err(<A::Error as de::Error>::duplicate_field(
7317										"mainEntity",
7318									));
7319								}
7320								r#main_entity_property = Some({
7321									struct DeserializeWith(Vec<MainEntityProperty>);
7322									impl<'de> Deserialize<'de> for DeserializeWith {
7323										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7324										where
7325											D: Deserializer<'de>,
7326										{
7327											Ok(DeserializeWith(serde_with::As::<
7328												serde_with::OneOrMany<serde_with::Same>,
7329											>::deserialize(deserializer)?))
7330										}
7331									}
7332									match map.next_value::<DeserializeWith>() {
7333										Ok(deserialize_with) => deserialize_with.0,
7334										Err(err) => {
7335											return Err(err);
7336										}
7337									}
7338								});
7339							}
7340							Field::Maintainer => {
7341								if r#maintainer_property.is_some() {
7342									return Err(<A::Error as de::Error>::duplicate_field(
7343										"maintainer",
7344									));
7345								}
7346								r#maintainer_property = Some({
7347									struct DeserializeWith(Vec<MaintainerProperty>);
7348									impl<'de> Deserialize<'de> for DeserializeWith {
7349										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7350										where
7351											D: Deserializer<'de>,
7352										{
7353											Ok(DeserializeWith(serde_with::As::<
7354												serde_with::OneOrMany<serde_with::Same>,
7355											>::deserialize(deserializer)?))
7356										}
7357									}
7358									match map.next_value::<DeserializeWith>() {
7359										Ok(deserialize_with) => deserialize_with.0,
7360										Err(err) => {
7361											return Err(err);
7362										}
7363									}
7364								});
7365							}
7366							Field::Material => {
7367								if r#material_property.is_some() {
7368									return Err(<A::Error as de::Error>::duplicate_field(
7369										"material",
7370									));
7371								}
7372								r#material_property = Some({
7373									struct DeserializeWith(Vec<MaterialProperty>);
7374									impl<'de> Deserialize<'de> for DeserializeWith {
7375										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7376										where
7377											D: Deserializer<'de>,
7378										{
7379											Ok(DeserializeWith(serde_with::As::<
7380												serde_with::OneOrMany<serde_with::Same>,
7381											>::deserialize(deserializer)?))
7382										}
7383									}
7384									match map.next_value::<DeserializeWith>() {
7385										Ok(deserialize_with) => deserialize_with.0,
7386										Err(err) => {
7387											return Err(err);
7388										}
7389									}
7390								});
7391							}
7392							Field::MaterialExtent => {
7393								if r#material_extent_property.is_some() {
7394									return Err(<A::Error as de::Error>::duplicate_field(
7395										"materialExtent",
7396									));
7397								}
7398								r#material_extent_property = Some({
7399									struct DeserializeWith(Vec<MaterialExtentProperty>);
7400									impl<'de> Deserialize<'de> for DeserializeWith {
7401										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7402										where
7403											D: Deserializer<'de>,
7404										{
7405											Ok(DeserializeWith(serde_with::As::<
7406												serde_with::OneOrMany<serde_with::Same>,
7407											>::deserialize(deserializer)?))
7408										}
7409									}
7410									match map.next_value::<DeserializeWith>() {
7411										Ok(deserialize_with) => deserialize_with.0,
7412										Err(err) => {
7413											return Err(err);
7414										}
7415									}
7416								});
7417							}
7418							Field::Mentions => {
7419								if r#mentions_property.is_some() {
7420									return Err(<A::Error as de::Error>::duplicate_field(
7421										"mentions",
7422									));
7423								}
7424								r#mentions_property = Some({
7425									struct DeserializeWith(Vec<MentionsProperty>);
7426									impl<'de> Deserialize<'de> for DeserializeWith {
7427										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7428										where
7429											D: Deserializer<'de>,
7430										{
7431											Ok(DeserializeWith(serde_with::As::<
7432												serde_with::OneOrMany<serde_with::Same>,
7433											>::deserialize(deserializer)?))
7434										}
7435									}
7436									match map.next_value::<DeserializeWith>() {
7437										Ok(deserialize_with) => deserialize_with.0,
7438										Err(err) => {
7439											return Err(err);
7440										}
7441									}
7442								});
7443							}
7444							Field::Offers => {
7445								if r#offers_property.is_some() {
7446									return Err(<A::Error as de::Error>::duplicate_field("offers"));
7447								}
7448								r#offers_property = Some({
7449									struct DeserializeWith(Vec<OffersProperty>);
7450									impl<'de> Deserialize<'de> for DeserializeWith {
7451										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7452										where
7453											D: Deserializer<'de>,
7454										{
7455											Ok(DeserializeWith(serde_with::As::<
7456												serde_with::OneOrMany<serde_with::Same>,
7457											>::deserialize(deserializer)?))
7458										}
7459									}
7460									match map.next_value::<DeserializeWith>() {
7461										Ok(deserialize_with) => deserialize_with.0,
7462										Err(err) => {
7463											return Err(err);
7464										}
7465									}
7466								});
7467							}
7468							Field::Pattern => {
7469								if r#pattern_property.is_some() {
7470									return Err(<A::Error as de::Error>::duplicate_field(
7471										"pattern",
7472									));
7473								}
7474								r#pattern_property = Some({
7475									struct DeserializeWith(Vec<PatternProperty>);
7476									impl<'de> Deserialize<'de> for DeserializeWith {
7477										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7478										where
7479											D: Deserializer<'de>,
7480										{
7481											Ok(DeserializeWith(serde_with::As::<
7482												serde_with::OneOrMany<serde_with::Same>,
7483											>::deserialize(deserializer)?))
7484										}
7485									}
7486									match map.next_value::<DeserializeWith>() {
7487										Ok(deserialize_with) => deserialize_with.0,
7488										Err(err) => {
7489											return Err(err);
7490										}
7491									}
7492								});
7493							}
7494							Field::Position => {
7495								if r#position_property.is_some() {
7496									return Err(<A::Error as de::Error>::duplicate_field(
7497										"position",
7498									));
7499								}
7500								r#position_property = Some({
7501									struct DeserializeWith(Vec<PositionProperty>);
7502									impl<'de> Deserialize<'de> for DeserializeWith {
7503										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7504										where
7505											D: Deserializer<'de>,
7506										{
7507											Ok(DeserializeWith(serde_with::As::<
7508												serde_with::OneOrMany<serde_with::Same>,
7509											>::deserialize(deserializer)?))
7510										}
7511									}
7512									match map.next_value::<DeserializeWith>() {
7513										Ok(deserialize_with) => deserialize_with.0,
7514										Err(err) => {
7515											return Err(err);
7516										}
7517									}
7518								});
7519							}
7520							Field::Producer => {
7521								if r#producer_property.is_some() {
7522									return Err(<A::Error as de::Error>::duplicate_field(
7523										"producer",
7524									));
7525								}
7526								r#producer_property = Some({
7527									struct DeserializeWith(Vec<ProducerProperty>);
7528									impl<'de> Deserialize<'de> for DeserializeWith {
7529										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7530										where
7531											D: Deserializer<'de>,
7532										{
7533											Ok(DeserializeWith(serde_with::As::<
7534												serde_with::OneOrMany<serde_with::Same>,
7535											>::deserialize(deserializer)?))
7536										}
7537									}
7538									match map.next_value::<DeserializeWith>() {
7539										Ok(deserialize_with) => deserialize_with.0,
7540										Err(err) => {
7541											return Err(err);
7542										}
7543									}
7544								});
7545							}
7546							Field::Provider => {
7547								if r#provider_property.is_some() {
7548									return Err(<A::Error as de::Error>::duplicate_field(
7549										"provider",
7550									));
7551								}
7552								r#provider_property = Some({
7553									struct DeserializeWith(Vec<ProviderProperty>);
7554									impl<'de> Deserialize<'de> for DeserializeWith {
7555										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7556										where
7557											D: Deserializer<'de>,
7558										{
7559											Ok(DeserializeWith(serde_with::As::<
7560												serde_with::OneOrMany<serde_with::Same>,
7561											>::deserialize(deserializer)?))
7562										}
7563									}
7564									match map.next_value::<DeserializeWith>() {
7565										Ok(deserialize_with) => deserialize_with.0,
7566										Err(err) => {
7567											return Err(err);
7568										}
7569									}
7570								});
7571							}
7572							Field::Publication => {
7573								if r#publication_property.is_some() {
7574									return Err(<A::Error as de::Error>::duplicate_field(
7575										"publication",
7576									));
7577								}
7578								r#publication_property = Some({
7579									struct DeserializeWith(Vec<PublicationProperty>);
7580									impl<'de> Deserialize<'de> for DeserializeWith {
7581										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7582										where
7583											D: Deserializer<'de>,
7584										{
7585											Ok(DeserializeWith(serde_with::As::<
7586												serde_with::OneOrMany<serde_with::Same>,
7587											>::deserialize(deserializer)?))
7588										}
7589									}
7590									match map.next_value::<DeserializeWith>() {
7591										Ok(deserialize_with) => deserialize_with.0,
7592										Err(err) => {
7593											return Err(err);
7594										}
7595									}
7596								});
7597							}
7598							Field::Publisher => {
7599								if r#publisher_property.is_some() {
7600									return Err(<A::Error as de::Error>::duplicate_field(
7601										"publisher",
7602									));
7603								}
7604								r#publisher_property = Some({
7605									struct DeserializeWith(Vec<PublisherProperty>);
7606									impl<'de> Deserialize<'de> for DeserializeWith {
7607										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7608										where
7609											D: Deserializer<'de>,
7610										{
7611											Ok(DeserializeWith(serde_with::As::<
7612												serde_with::OneOrMany<serde_with::Same>,
7613											>::deserialize(deserializer)?))
7614										}
7615									}
7616									match map.next_value::<DeserializeWith>() {
7617										Ok(deserialize_with) => deserialize_with.0,
7618										Err(err) => {
7619											return Err(err);
7620										}
7621									}
7622								});
7623							}
7624							Field::PublisherImprint => {
7625								if r#publisher_imprint_property.is_some() {
7626									return Err(<A::Error as de::Error>::duplicate_field(
7627										"publisherImprint",
7628									));
7629								}
7630								r#publisher_imprint_property = Some({
7631									struct DeserializeWith(Vec<PublisherImprintProperty>);
7632									impl<'de> Deserialize<'de> for DeserializeWith {
7633										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7634										where
7635											D: Deserializer<'de>,
7636										{
7637											Ok(DeserializeWith(serde_with::As::<
7638												serde_with::OneOrMany<serde_with::Same>,
7639											>::deserialize(deserializer)?))
7640										}
7641									}
7642									match map.next_value::<DeserializeWith>() {
7643										Ok(deserialize_with) => deserialize_with.0,
7644										Err(err) => {
7645											return Err(err);
7646										}
7647									}
7648								});
7649							}
7650							Field::PublishingPrinciples => {
7651								if r#publishing_principles_property.is_some() {
7652									return Err(<A::Error as de::Error>::duplicate_field(
7653										"publishingPrinciples",
7654									));
7655								}
7656								r#publishing_principles_property = Some({
7657									struct DeserializeWith(Vec<PublishingPrinciplesProperty>);
7658									impl<'de> Deserialize<'de> for DeserializeWith {
7659										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7660										where
7661											D: Deserializer<'de>,
7662										{
7663											Ok(DeserializeWith(serde_with::As::<
7664												serde_with::OneOrMany<serde_with::Same>,
7665											>::deserialize(deserializer)?))
7666										}
7667									}
7668									match map.next_value::<DeserializeWith>() {
7669										Ok(deserialize_with) => deserialize_with.0,
7670										Err(err) => {
7671											return Err(err);
7672										}
7673									}
7674								});
7675							}
7676							Field::RecordedAt => {
7677								if r#recorded_at_property.is_some() {
7678									return Err(<A::Error as de::Error>::duplicate_field(
7679										"recordedAt",
7680									));
7681								}
7682								r#recorded_at_property = Some({
7683									struct DeserializeWith(Vec<RecordedAtProperty>);
7684									impl<'de> Deserialize<'de> for DeserializeWith {
7685										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7686										where
7687											D: Deserializer<'de>,
7688										{
7689											Ok(DeserializeWith(serde_with::As::<
7690												serde_with::OneOrMany<serde_with::Same>,
7691											>::deserialize(deserializer)?))
7692										}
7693									}
7694									match map.next_value::<DeserializeWith>() {
7695										Ok(deserialize_with) => deserialize_with.0,
7696										Err(err) => {
7697											return Err(err);
7698										}
7699									}
7700								});
7701							}
7702							Field::ReleasedEvent => {
7703								if r#released_event_property.is_some() {
7704									return Err(<A::Error as de::Error>::duplicate_field(
7705										"releasedEvent",
7706									));
7707								}
7708								r#released_event_property = Some({
7709									struct DeserializeWith(Vec<ReleasedEventProperty>);
7710									impl<'de> Deserialize<'de> for DeserializeWith {
7711										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7712										where
7713											D: Deserializer<'de>,
7714										{
7715											Ok(DeserializeWith(serde_with::As::<
7716												serde_with::OneOrMany<serde_with::Same>,
7717											>::deserialize(deserializer)?))
7718										}
7719									}
7720									match map.next_value::<DeserializeWith>() {
7721										Ok(deserialize_with) => deserialize_with.0,
7722										Err(err) => {
7723											return Err(err);
7724										}
7725									}
7726								});
7727							}
7728							Field::Review => {
7729								if r#review_property.is_some() {
7730									return Err(<A::Error as de::Error>::duplicate_field("review"));
7731								}
7732								r#review_property = Some({
7733									struct DeserializeWith(Vec<ReviewProperty>);
7734									impl<'de> Deserialize<'de> for DeserializeWith {
7735										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7736										where
7737											D: Deserializer<'de>,
7738										{
7739											Ok(DeserializeWith(serde_with::As::<
7740												serde_with::OneOrMany<serde_with::Same>,
7741											>::deserialize(deserializer)?))
7742										}
7743									}
7744									match map.next_value::<DeserializeWith>() {
7745										Ok(deserialize_with) => deserialize_with.0,
7746										Err(err) => {
7747											return Err(err);
7748										}
7749									}
7750								});
7751							}
7752							Field::Reviews => {
7753								if r#reviews_property.is_some() {
7754									return Err(<A::Error as de::Error>::duplicate_field(
7755										"reviews",
7756									));
7757								}
7758								r#reviews_property = Some({
7759									struct DeserializeWith(Vec<ReviewsProperty>);
7760									impl<'de> Deserialize<'de> for DeserializeWith {
7761										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7762										where
7763											D: Deserializer<'de>,
7764										{
7765											Ok(DeserializeWith(serde_with::As::<
7766												serde_with::OneOrMany<serde_with::Same>,
7767											>::deserialize(deserializer)?))
7768										}
7769									}
7770									match map.next_value::<DeserializeWith>() {
7771										Ok(deserialize_with) => deserialize_with.0,
7772										Err(err) => {
7773											return Err(err);
7774										}
7775									}
7776								});
7777							}
7778							Field::SchemaVersion => {
7779								if r#schema_version_property.is_some() {
7780									return Err(<A::Error as de::Error>::duplicate_field(
7781										"schemaVersion",
7782									));
7783								}
7784								r#schema_version_property = Some({
7785									struct DeserializeWith(Vec<SchemaVersionProperty>);
7786									impl<'de> Deserialize<'de> for DeserializeWith {
7787										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7788										where
7789											D: Deserializer<'de>,
7790										{
7791											Ok(DeserializeWith(serde_with::As::<
7792												serde_with::OneOrMany<serde_with::Same>,
7793											>::deserialize(deserializer)?))
7794										}
7795									}
7796									match map.next_value::<DeserializeWith>() {
7797										Ok(deserialize_with) => deserialize_with.0,
7798										Err(err) => {
7799											return Err(err);
7800										}
7801									}
7802								});
7803							}
7804							Field::SdDatePublished => {
7805								if r#sd_date_published_property.is_some() {
7806									return Err(<A::Error as de::Error>::duplicate_field(
7807										"sdDatePublished",
7808									));
7809								}
7810								r#sd_date_published_property = Some({
7811									struct DeserializeWith(Vec<SdDatePublishedProperty>);
7812									impl<'de> Deserialize<'de> for DeserializeWith {
7813										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7814										where
7815											D: Deserializer<'de>,
7816										{
7817											Ok(DeserializeWith(serde_with::As::<
7818												serde_with::OneOrMany<serde_with::Same>,
7819											>::deserialize(deserializer)?))
7820										}
7821									}
7822									match map.next_value::<DeserializeWith>() {
7823										Ok(deserialize_with) => deserialize_with.0,
7824										Err(err) => {
7825											return Err(err);
7826										}
7827									}
7828								});
7829							}
7830							Field::SdLicense => {
7831								if r#sd_license_property.is_some() {
7832									return Err(<A::Error as de::Error>::duplicate_field(
7833										"sdLicense",
7834									));
7835								}
7836								r#sd_license_property = Some({
7837									struct DeserializeWith(Vec<SdLicenseProperty>);
7838									impl<'de> Deserialize<'de> for DeserializeWith {
7839										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7840										where
7841											D: Deserializer<'de>,
7842										{
7843											Ok(DeserializeWith(serde_with::As::<
7844												serde_with::OneOrMany<serde_with::Same>,
7845											>::deserialize(deserializer)?))
7846										}
7847									}
7848									match map.next_value::<DeserializeWith>() {
7849										Ok(deserialize_with) => deserialize_with.0,
7850										Err(err) => {
7851											return Err(err);
7852										}
7853									}
7854								});
7855							}
7856							Field::SdPublisher => {
7857								if r#sd_publisher_property.is_some() {
7858									return Err(<A::Error as de::Error>::duplicate_field(
7859										"sdPublisher",
7860									));
7861								}
7862								r#sd_publisher_property = Some({
7863									struct DeserializeWith(Vec<SdPublisherProperty>);
7864									impl<'de> Deserialize<'de> for DeserializeWith {
7865										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7866										where
7867											D: Deserializer<'de>,
7868										{
7869											Ok(DeserializeWith(serde_with::As::<
7870												serde_with::OneOrMany<serde_with::Same>,
7871											>::deserialize(deserializer)?))
7872										}
7873									}
7874									match map.next_value::<DeserializeWith>() {
7875										Ok(deserialize_with) => deserialize_with.0,
7876										Err(err) => {
7877											return Err(err);
7878										}
7879									}
7880								});
7881							}
7882							Field::Size => {
7883								if r#size_property.is_some() {
7884									return Err(<A::Error as de::Error>::duplicate_field("size"));
7885								}
7886								r#size_property = Some({
7887									struct DeserializeWith(Vec<SizeProperty>);
7888									impl<'de> Deserialize<'de> for DeserializeWith {
7889										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7890										where
7891											D: Deserializer<'de>,
7892										{
7893											Ok(DeserializeWith(serde_with::As::<
7894												serde_with::OneOrMany<serde_with::Same>,
7895											>::deserialize(deserializer)?))
7896										}
7897									}
7898									match map.next_value::<DeserializeWith>() {
7899										Ok(deserialize_with) => deserialize_with.0,
7900										Err(err) => {
7901											return Err(err);
7902										}
7903									}
7904								});
7905							}
7906							Field::SourceOrganization => {
7907								if r#source_organization_property.is_some() {
7908									return Err(<A::Error as de::Error>::duplicate_field(
7909										"sourceOrganization",
7910									));
7911								}
7912								r#source_organization_property = Some({
7913									struct DeserializeWith(Vec<SourceOrganizationProperty>);
7914									impl<'de> Deserialize<'de> for DeserializeWith {
7915										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7916										where
7917											D: Deserializer<'de>,
7918										{
7919											Ok(DeserializeWith(serde_with::As::<
7920												serde_with::OneOrMany<serde_with::Same>,
7921											>::deserialize(deserializer)?))
7922										}
7923									}
7924									match map.next_value::<DeserializeWith>() {
7925										Ok(deserialize_with) => deserialize_with.0,
7926										Err(err) => {
7927											return Err(err);
7928										}
7929									}
7930								});
7931							}
7932							Field::Spatial => {
7933								if r#spatial_property.is_some() {
7934									return Err(<A::Error as de::Error>::duplicate_field(
7935										"spatial",
7936									));
7937								}
7938								r#spatial_property = Some({
7939									struct DeserializeWith(Vec<SpatialProperty>);
7940									impl<'de> Deserialize<'de> for DeserializeWith {
7941										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7942										where
7943											D: Deserializer<'de>,
7944										{
7945											Ok(DeserializeWith(serde_with::As::<
7946												serde_with::OneOrMany<serde_with::Same>,
7947											>::deserialize(deserializer)?))
7948										}
7949									}
7950									match map.next_value::<DeserializeWith>() {
7951										Ok(deserialize_with) => deserialize_with.0,
7952										Err(err) => {
7953											return Err(err);
7954										}
7955									}
7956								});
7957							}
7958							Field::SpatialCoverage => {
7959								if r#spatial_coverage_property.is_some() {
7960									return Err(<A::Error as de::Error>::duplicate_field(
7961										"spatialCoverage",
7962									));
7963								}
7964								r#spatial_coverage_property = Some({
7965									struct DeserializeWith(Vec<SpatialCoverageProperty>);
7966									impl<'de> Deserialize<'de> for DeserializeWith {
7967										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7968										where
7969											D: Deserializer<'de>,
7970										{
7971											Ok(DeserializeWith(serde_with::As::<
7972												serde_with::OneOrMany<serde_with::Same>,
7973											>::deserialize(deserializer)?))
7974										}
7975									}
7976									match map.next_value::<DeserializeWith>() {
7977										Ok(deserialize_with) => deserialize_with.0,
7978										Err(err) => {
7979											return Err(err);
7980										}
7981									}
7982								});
7983							}
7984							Field::Sponsor => {
7985								if r#sponsor_property.is_some() {
7986									return Err(<A::Error as de::Error>::duplicate_field(
7987										"sponsor",
7988									));
7989								}
7990								r#sponsor_property = Some({
7991									struct DeserializeWith(Vec<SponsorProperty>);
7992									impl<'de> Deserialize<'de> for DeserializeWith {
7993										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7994										where
7995											D: Deserializer<'de>,
7996										{
7997											Ok(DeserializeWith(serde_with::As::<
7998												serde_with::OneOrMany<serde_with::Same>,
7999											>::deserialize(deserializer)?))
8000										}
8001									}
8002									match map.next_value::<DeserializeWith>() {
8003										Ok(deserialize_with) => deserialize_with.0,
8004										Err(err) => {
8005											return Err(err);
8006										}
8007									}
8008								});
8009							}
8010							Field::Teaches => {
8011								if r#teaches_property.is_some() {
8012									return Err(<A::Error as de::Error>::duplicate_field(
8013										"teaches",
8014									));
8015								}
8016								r#teaches_property = Some({
8017									struct DeserializeWith(Vec<TeachesProperty>);
8018									impl<'de> Deserialize<'de> for DeserializeWith {
8019										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8020										where
8021											D: Deserializer<'de>,
8022										{
8023											Ok(DeserializeWith(serde_with::As::<
8024												serde_with::OneOrMany<serde_with::Same>,
8025											>::deserialize(deserializer)?))
8026										}
8027									}
8028									match map.next_value::<DeserializeWith>() {
8029										Ok(deserialize_with) => deserialize_with.0,
8030										Err(err) => {
8031											return Err(err);
8032										}
8033									}
8034								});
8035							}
8036							Field::Temporal => {
8037								if r#temporal_property.is_some() {
8038									return Err(<A::Error as de::Error>::duplicate_field(
8039										"temporal",
8040									));
8041								}
8042								r#temporal_property = Some({
8043									struct DeserializeWith(Vec<TemporalProperty>);
8044									impl<'de> Deserialize<'de> for DeserializeWith {
8045										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8046										where
8047											D: Deserializer<'de>,
8048										{
8049											Ok(DeserializeWith(serde_with::As::<
8050												serde_with::OneOrMany<serde_with::Same>,
8051											>::deserialize(deserializer)?))
8052										}
8053									}
8054									match map.next_value::<DeserializeWith>() {
8055										Ok(deserialize_with) => deserialize_with.0,
8056										Err(err) => {
8057											return Err(err);
8058										}
8059									}
8060								});
8061							}
8062							Field::TemporalCoverage => {
8063								if r#temporal_coverage_property.is_some() {
8064									return Err(<A::Error as de::Error>::duplicate_field(
8065										"temporalCoverage",
8066									));
8067								}
8068								r#temporal_coverage_property = Some({
8069									struct DeserializeWith(Vec<TemporalCoverageProperty>);
8070									impl<'de> Deserialize<'de> for DeserializeWith {
8071										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8072										where
8073											D: Deserializer<'de>,
8074										{
8075											Ok(DeserializeWith(serde_with::As::<
8076												serde_with::OneOrMany<serde_with::Same>,
8077											>::deserialize(deserializer)?))
8078										}
8079									}
8080									match map.next_value::<DeserializeWith>() {
8081										Ok(deserialize_with) => deserialize_with.0,
8082										Err(err) => {
8083											return Err(err);
8084										}
8085									}
8086								});
8087							}
8088							Field::Text => {
8089								if r#text_property.is_some() {
8090									return Err(<A::Error as de::Error>::duplicate_field("text"));
8091								}
8092								r#text_property = Some({
8093									struct DeserializeWith(Vec<TextProperty>);
8094									impl<'de> Deserialize<'de> for DeserializeWith {
8095										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8096										where
8097											D: Deserializer<'de>,
8098										{
8099											Ok(DeserializeWith(serde_with::As::<
8100												serde_with::OneOrMany<serde_with::Same>,
8101											>::deserialize(deserializer)?))
8102										}
8103									}
8104									match map.next_value::<DeserializeWith>() {
8105										Ok(deserialize_with) => deserialize_with.0,
8106										Err(err) => {
8107											return Err(err);
8108										}
8109									}
8110								});
8111							}
8112							Field::Thumbnail => {
8113								if r#thumbnail_property.is_some() {
8114									return Err(<A::Error as de::Error>::duplicate_field(
8115										"thumbnail",
8116									));
8117								}
8118								r#thumbnail_property = Some({
8119									struct DeserializeWith(Vec<ThumbnailProperty>);
8120									impl<'de> Deserialize<'de> for DeserializeWith {
8121										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8122										where
8123											D: Deserializer<'de>,
8124										{
8125											Ok(DeserializeWith(serde_with::As::<
8126												serde_with::OneOrMany<serde_with::Same>,
8127											>::deserialize(deserializer)?))
8128										}
8129									}
8130									match map.next_value::<DeserializeWith>() {
8131										Ok(deserialize_with) => deserialize_with.0,
8132										Err(err) => {
8133											return Err(err);
8134										}
8135									}
8136								});
8137							}
8138							Field::ThumbnailUrl => {
8139								if r#thumbnail_url_property.is_some() {
8140									return Err(<A::Error as de::Error>::duplicate_field(
8141										"thumbnailUrl",
8142									));
8143								}
8144								r#thumbnail_url_property = Some({
8145									struct DeserializeWith(Vec<ThumbnailUrlProperty>);
8146									impl<'de> Deserialize<'de> for DeserializeWith {
8147										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8148										where
8149											D: Deserializer<'de>,
8150										{
8151											Ok(DeserializeWith(serde_with::As::<
8152												serde_with::OneOrMany<serde_with::Same>,
8153											>::deserialize(deserializer)?))
8154										}
8155									}
8156									match map.next_value::<DeserializeWith>() {
8157										Ok(deserialize_with) => deserialize_with.0,
8158										Err(err) => {
8159											return Err(err);
8160										}
8161									}
8162								});
8163							}
8164							Field::TimeRequired => {
8165								if r#time_required_property.is_some() {
8166									return Err(<A::Error as de::Error>::duplicate_field(
8167										"timeRequired",
8168									));
8169								}
8170								r#time_required_property = Some({
8171									struct DeserializeWith(Vec<TimeRequiredProperty>);
8172									impl<'de> Deserialize<'de> for DeserializeWith {
8173										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8174										where
8175											D: Deserializer<'de>,
8176										{
8177											Ok(DeserializeWith(serde_with::As::<
8178												serde_with::OneOrMany<serde_with::Same>,
8179											>::deserialize(deserializer)?))
8180										}
8181									}
8182									match map.next_value::<DeserializeWith>() {
8183										Ok(deserialize_with) => deserialize_with.0,
8184										Err(err) => {
8185											return Err(err);
8186										}
8187									}
8188								});
8189							}
8190							Field::TranslationOfWork => {
8191								if r#translation_of_work_property.is_some() {
8192									return Err(<A::Error as de::Error>::duplicate_field(
8193										"translationOfWork",
8194									));
8195								}
8196								r#translation_of_work_property = Some({
8197									struct DeserializeWith(Vec<TranslationOfWorkProperty>);
8198									impl<'de> Deserialize<'de> for DeserializeWith {
8199										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8200										where
8201											D: Deserializer<'de>,
8202										{
8203											Ok(DeserializeWith(serde_with::As::<
8204												serde_with::OneOrMany<serde_with::Same>,
8205											>::deserialize(deserializer)?))
8206										}
8207									}
8208									match map.next_value::<DeserializeWith>() {
8209										Ok(deserialize_with) => deserialize_with.0,
8210										Err(err) => {
8211											return Err(err);
8212										}
8213									}
8214								});
8215							}
8216							Field::Translator => {
8217								if r#translator_property.is_some() {
8218									return Err(<A::Error as de::Error>::duplicate_field(
8219										"translator",
8220									));
8221								}
8222								r#translator_property = Some({
8223									struct DeserializeWith(Vec<TranslatorProperty>);
8224									impl<'de> Deserialize<'de> for DeserializeWith {
8225										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8226										where
8227											D: Deserializer<'de>,
8228										{
8229											Ok(DeserializeWith(serde_with::As::<
8230												serde_with::OneOrMany<serde_with::Same>,
8231											>::deserialize(deserializer)?))
8232										}
8233									}
8234									match map.next_value::<DeserializeWith>() {
8235										Ok(deserialize_with) => deserialize_with.0,
8236										Err(err) => {
8237											return Err(err);
8238										}
8239									}
8240								});
8241							}
8242							Field::TypicalAgeRange => {
8243								if r#typical_age_range_property.is_some() {
8244									return Err(<A::Error as de::Error>::duplicate_field(
8245										"typicalAgeRange",
8246									));
8247								}
8248								r#typical_age_range_property = Some({
8249									struct DeserializeWith(Vec<TypicalAgeRangeProperty>);
8250									impl<'de> Deserialize<'de> for DeserializeWith {
8251										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8252										where
8253											D: Deserializer<'de>,
8254										{
8255											Ok(DeserializeWith(serde_with::As::<
8256												serde_with::OneOrMany<serde_with::Same>,
8257											>::deserialize(deserializer)?))
8258										}
8259									}
8260									match map.next_value::<DeserializeWith>() {
8261										Ok(deserialize_with) => deserialize_with.0,
8262										Err(err) => {
8263											return Err(err);
8264										}
8265									}
8266								});
8267							}
8268							Field::UsageInfo => {
8269								if r#usage_info_property.is_some() {
8270									return Err(<A::Error as de::Error>::duplicate_field(
8271										"usageInfo",
8272									));
8273								}
8274								r#usage_info_property = Some({
8275									struct DeserializeWith(Vec<UsageInfoProperty>);
8276									impl<'de> Deserialize<'de> for DeserializeWith {
8277										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8278										where
8279											D: Deserializer<'de>,
8280										{
8281											Ok(DeserializeWith(serde_with::As::<
8282												serde_with::OneOrMany<serde_with::Same>,
8283											>::deserialize(deserializer)?))
8284										}
8285									}
8286									match map.next_value::<DeserializeWith>() {
8287										Ok(deserialize_with) => deserialize_with.0,
8288										Err(err) => {
8289											return Err(err);
8290										}
8291									}
8292								});
8293							}
8294							Field::Version => {
8295								if r#version_property.is_some() {
8296									return Err(<A::Error as de::Error>::duplicate_field(
8297										"version",
8298									));
8299								}
8300								r#version_property = Some({
8301									struct DeserializeWith(Vec<VersionProperty>);
8302									impl<'de> Deserialize<'de> for DeserializeWith {
8303										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8304										where
8305											D: Deserializer<'de>,
8306										{
8307											Ok(DeserializeWith(serde_with::As::<
8308												serde_with::OneOrMany<serde_with::Same>,
8309											>::deserialize(deserializer)?))
8310										}
8311									}
8312									match map.next_value::<DeserializeWith>() {
8313										Ok(deserialize_with) => deserialize_with.0,
8314										Err(err) => {
8315											return Err(err);
8316										}
8317									}
8318								});
8319							}
8320							Field::Video => {
8321								if r#video_property.is_some() {
8322									return Err(<A::Error as de::Error>::duplicate_field("video"));
8323								}
8324								r#video_property = Some({
8325									struct DeserializeWith(Vec<VideoProperty>);
8326									impl<'de> Deserialize<'de> for DeserializeWith {
8327										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8328										where
8329											D: Deserializer<'de>,
8330										{
8331											Ok(DeserializeWith(serde_with::As::<
8332												serde_with::OneOrMany<serde_with::Same>,
8333											>::deserialize(deserializer)?))
8334										}
8335									}
8336									match map.next_value::<DeserializeWith>() {
8337										Ok(deserialize_with) => deserialize_with.0,
8338										Err(err) => {
8339											return Err(err);
8340										}
8341									}
8342								});
8343							}
8344							Field::WorkExample => {
8345								if r#work_example_property.is_some() {
8346									return Err(<A::Error as de::Error>::duplicate_field(
8347										"workExample",
8348									));
8349								}
8350								r#work_example_property = Some({
8351									struct DeserializeWith(Vec<WorkExampleProperty>);
8352									impl<'de> Deserialize<'de> for DeserializeWith {
8353										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8354										where
8355											D: Deserializer<'de>,
8356										{
8357											Ok(DeserializeWith(serde_with::As::<
8358												serde_with::OneOrMany<serde_with::Same>,
8359											>::deserialize(deserializer)?))
8360										}
8361									}
8362									match map.next_value::<DeserializeWith>() {
8363										Ok(deserialize_with) => deserialize_with.0,
8364										Err(err) => {
8365											return Err(err);
8366										}
8367									}
8368								});
8369							}
8370							Field::WorkTranslation => {
8371								if r#work_translation_property.is_some() {
8372									return Err(<A::Error as de::Error>::duplicate_field(
8373										"workTranslation",
8374									));
8375								}
8376								r#work_translation_property = Some({
8377									struct DeserializeWith(Vec<WorkTranslationProperty>);
8378									impl<'de> Deserialize<'de> for DeserializeWith {
8379										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8380										where
8381											D: Deserializer<'de>,
8382										{
8383											Ok(DeserializeWith(serde_with::As::<
8384												serde_with::OneOrMany<serde_with::Same>,
8385											>::deserialize(deserializer)?))
8386										}
8387									}
8388									match map.next_value::<DeserializeWith>() {
8389										Ok(deserialize_with) => deserialize_with.0,
8390										Err(err) => {
8391											return Err(err);
8392										}
8393									}
8394								});
8395							}
8396							Field::AdditionalProperty => {
8397								if r#additional_property_property.is_some() {
8398									return Err(<A::Error as de::Error>::duplicate_field(
8399										"additionalProperty",
8400									));
8401								}
8402								r#additional_property_property = Some({
8403									struct DeserializeWith(Vec<AdditionalPropertyProperty>);
8404									impl<'de> Deserialize<'de> for DeserializeWith {
8405										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8406										where
8407											D: Deserializer<'de>,
8408										{
8409											Ok(DeserializeWith(serde_with::As::<
8410												serde_with::OneOrMany<serde_with::Same>,
8411											>::deserialize(deserializer)?))
8412										}
8413									}
8414									match map.next_value::<DeserializeWith>() {
8415										Ok(deserialize_with) => deserialize_with.0,
8416										Err(err) => {
8417											return Err(err);
8418										}
8419									}
8420								});
8421							}
8422							Field::Asin => {
8423								if r#asin_property.is_some() {
8424									return Err(<A::Error as de::Error>::duplicate_field("asin"));
8425								}
8426								r#asin_property = Some({
8427									struct DeserializeWith(Vec<AsinProperty>);
8428									impl<'de> Deserialize<'de> for DeserializeWith {
8429										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8430										where
8431											D: Deserializer<'de>,
8432										{
8433											Ok(DeserializeWith(serde_with::As::<
8434												serde_with::OneOrMany<serde_with::Same>,
8435											>::deserialize(deserializer)?))
8436										}
8437									}
8438									match map.next_value::<DeserializeWith>() {
8439										Ok(deserialize_with) => deserialize_with.0,
8440										Err(err) => {
8441											return Err(err);
8442										}
8443									}
8444								});
8445							}
8446							Field::Brand => {
8447								if r#brand_property.is_some() {
8448									return Err(<A::Error as de::Error>::duplicate_field("brand"));
8449								}
8450								r#brand_property = Some({
8451									struct DeserializeWith(Vec<BrandProperty>);
8452									impl<'de> Deserialize<'de> for DeserializeWith {
8453										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8454										where
8455											D: Deserializer<'de>,
8456										{
8457											Ok(DeserializeWith(serde_with::As::<
8458												serde_with::OneOrMany<serde_with::Same>,
8459											>::deserialize(deserializer)?))
8460										}
8461									}
8462									match map.next_value::<DeserializeWith>() {
8463										Ok(deserialize_with) => deserialize_with.0,
8464										Err(err) => {
8465											return Err(err);
8466										}
8467									}
8468								});
8469							}
8470							Field::Category => {
8471								if r#category_property.is_some() {
8472									return Err(<A::Error as de::Error>::duplicate_field(
8473										"category",
8474									));
8475								}
8476								r#category_property = Some({
8477									struct DeserializeWith(Vec<CategoryProperty>);
8478									impl<'de> Deserialize<'de> for DeserializeWith {
8479										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8480										where
8481											D: Deserializer<'de>,
8482										{
8483											Ok(DeserializeWith(serde_with::As::<
8484												serde_with::OneOrMany<serde_with::Same>,
8485											>::deserialize(deserializer)?))
8486										}
8487									}
8488									match map.next_value::<DeserializeWith>() {
8489										Ok(deserialize_with) => deserialize_with.0,
8490										Err(err) => {
8491											return Err(err);
8492										}
8493									}
8494								});
8495							}
8496							Field::Color => {
8497								if r#color_property.is_some() {
8498									return Err(<A::Error as de::Error>::duplicate_field("color"));
8499								}
8500								r#color_property = Some({
8501									struct DeserializeWith(Vec<ColorProperty>);
8502									impl<'de> Deserialize<'de> for DeserializeWith {
8503										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8504										where
8505											D: Deserializer<'de>,
8506										{
8507											Ok(DeserializeWith(serde_with::As::<
8508												serde_with::OneOrMany<serde_with::Same>,
8509											>::deserialize(deserializer)?))
8510										}
8511									}
8512									match map.next_value::<DeserializeWith>() {
8513										Ok(deserialize_with) => deserialize_with.0,
8514										Err(err) => {
8515											return Err(err);
8516										}
8517									}
8518								});
8519							}
8520							Field::CountryOfAssembly => {
8521								if r#country_of_assembly_property.is_some() {
8522									return Err(<A::Error as de::Error>::duplicate_field(
8523										"countryOfAssembly",
8524									));
8525								}
8526								r#country_of_assembly_property = Some({
8527									struct DeserializeWith(Vec<CountryOfAssemblyProperty>);
8528									impl<'de> Deserialize<'de> for DeserializeWith {
8529										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8530										where
8531											D: Deserializer<'de>,
8532										{
8533											Ok(DeserializeWith(serde_with::As::<
8534												serde_with::OneOrMany<serde_with::Same>,
8535											>::deserialize(deserializer)?))
8536										}
8537									}
8538									match map.next_value::<DeserializeWith>() {
8539										Ok(deserialize_with) => deserialize_with.0,
8540										Err(err) => {
8541											return Err(err);
8542										}
8543									}
8544								});
8545							}
8546							Field::CountryOfLastProcessing => {
8547								if r#country_of_last_processing_property.is_some() {
8548									return Err(<A::Error as de::Error>::duplicate_field(
8549										"countryOfLastProcessing",
8550									));
8551								}
8552								r#country_of_last_processing_property = Some({
8553									struct DeserializeWith(Vec<CountryOfLastProcessingProperty>);
8554									impl<'de> Deserialize<'de> for DeserializeWith {
8555										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8556										where
8557											D: Deserializer<'de>,
8558										{
8559											Ok(DeserializeWith(serde_with::As::<
8560												serde_with::OneOrMany<serde_with::Same>,
8561											>::deserialize(deserializer)?))
8562										}
8563									}
8564									match map.next_value::<DeserializeWith>() {
8565										Ok(deserialize_with) => deserialize_with.0,
8566										Err(err) => {
8567											return Err(err);
8568										}
8569									}
8570								});
8571							}
8572							Field::Depth => {
8573								if r#depth_property.is_some() {
8574									return Err(<A::Error as de::Error>::duplicate_field("depth"));
8575								}
8576								r#depth_property = Some({
8577									struct DeserializeWith(Vec<DepthProperty>);
8578									impl<'de> Deserialize<'de> for DeserializeWith {
8579										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8580										where
8581											D: Deserializer<'de>,
8582										{
8583											Ok(DeserializeWith(serde_with::As::<
8584												serde_with::OneOrMany<serde_with::Same>,
8585											>::deserialize(deserializer)?))
8586										}
8587									}
8588									match map.next_value::<DeserializeWith>() {
8589										Ok(deserialize_with) => deserialize_with.0,
8590										Err(err) => {
8591											return Err(err);
8592										}
8593									}
8594								});
8595							}
8596							Field::Gtin => {
8597								if r#gtin_property.is_some() {
8598									return Err(<A::Error as de::Error>::duplicate_field("gtin"));
8599								}
8600								r#gtin_property = Some({
8601									struct DeserializeWith(Vec<GtinProperty>);
8602									impl<'de> Deserialize<'de> for DeserializeWith {
8603										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8604										where
8605											D: Deserializer<'de>,
8606										{
8607											Ok(DeserializeWith(serde_with::As::<
8608												serde_with::OneOrMany<serde_with::Same>,
8609											>::deserialize(deserializer)?))
8610										}
8611									}
8612									match map.next_value::<DeserializeWith>() {
8613										Ok(deserialize_with) => deserialize_with.0,
8614										Err(err) => {
8615											return Err(err);
8616										}
8617									}
8618								});
8619							}
8620							Field::Gtin12 => {
8621								if r#gtin_12_property.is_some() {
8622									return Err(<A::Error as de::Error>::duplicate_field("gtin12"));
8623								}
8624								r#gtin_12_property = Some({
8625									struct DeserializeWith(Vec<Gtin12Property>);
8626									impl<'de> Deserialize<'de> for DeserializeWith {
8627										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8628										where
8629											D: Deserializer<'de>,
8630										{
8631											Ok(DeserializeWith(serde_with::As::<
8632												serde_with::OneOrMany<serde_with::Same>,
8633											>::deserialize(deserializer)?))
8634										}
8635									}
8636									match map.next_value::<DeserializeWith>() {
8637										Ok(deserialize_with) => deserialize_with.0,
8638										Err(err) => {
8639											return Err(err);
8640										}
8641									}
8642								});
8643							}
8644							Field::Gtin13 => {
8645								if r#gtin_13_property.is_some() {
8646									return Err(<A::Error as de::Error>::duplicate_field("gtin13"));
8647								}
8648								r#gtin_13_property = Some({
8649									struct DeserializeWith(Vec<Gtin13Property>);
8650									impl<'de> Deserialize<'de> for DeserializeWith {
8651										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8652										where
8653											D: Deserializer<'de>,
8654										{
8655											Ok(DeserializeWith(serde_with::As::<
8656												serde_with::OneOrMany<serde_with::Same>,
8657											>::deserialize(deserializer)?))
8658										}
8659									}
8660									match map.next_value::<DeserializeWith>() {
8661										Ok(deserialize_with) => deserialize_with.0,
8662										Err(err) => {
8663											return Err(err);
8664										}
8665									}
8666								});
8667							}
8668							Field::Gtin14 => {
8669								if r#gtin_14_property.is_some() {
8670									return Err(<A::Error as de::Error>::duplicate_field("gtin14"));
8671								}
8672								r#gtin_14_property = Some({
8673									struct DeserializeWith(Vec<Gtin14Property>);
8674									impl<'de> Deserialize<'de> for DeserializeWith {
8675										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8676										where
8677											D: Deserializer<'de>,
8678										{
8679											Ok(DeserializeWith(serde_with::As::<
8680												serde_with::OneOrMany<serde_with::Same>,
8681											>::deserialize(deserializer)?))
8682										}
8683									}
8684									match map.next_value::<DeserializeWith>() {
8685										Ok(deserialize_with) => deserialize_with.0,
8686										Err(err) => {
8687											return Err(err);
8688										}
8689									}
8690								});
8691							}
8692							Field::Gtin8 => {
8693								if r#gtin_8_property.is_some() {
8694									return Err(<A::Error as de::Error>::duplicate_field("gtin8"));
8695								}
8696								r#gtin_8_property = Some({
8697									struct DeserializeWith(Vec<Gtin8Property>);
8698									impl<'de> Deserialize<'de> for DeserializeWith {
8699										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8700										where
8701											D: Deserializer<'de>,
8702										{
8703											Ok(DeserializeWith(serde_with::As::<
8704												serde_with::OneOrMany<serde_with::Same>,
8705											>::deserialize(deserializer)?))
8706										}
8707									}
8708									match map.next_value::<DeserializeWith>() {
8709										Ok(deserialize_with) => deserialize_with.0,
8710										Err(err) => {
8711											return Err(err);
8712										}
8713									}
8714								});
8715							}
8716							Field::HasAdultConsideration => {
8717								if r#has_adult_consideration_property.is_some() {
8718									return Err(<A::Error as de::Error>::duplicate_field(
8719										"hasAdultConsideration",
8720									));
8721								}
8722								r#has_adult_consideration_property = Some({
8723									struct DeserializeWith(Vec<HasAdultConsiderationProperty>);
8724									impl<'de> Deserialize<'de> for DeserializeWith {
8725										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8726										where
8727											D: Deserializer<'de>,
8728										{
8729											Ok(DeserializeWith(serde_with::As::<
8730												serde_with::OneOrMany<serde_with::Same>,
8731											>::deserialize(deserializer)?))
8732										}
8733									}
8734									match map.next_value::<DeserializeWith>() {
8735										Ok(deserialize_with) => deserialize_with.0,
8736										Err(err) => {
8737											return Err(err);
8738										}
8739									}
8740								});
8741							}
8742							Field::HasEnergyConsumptionDetails => {
8743								if r#has_energy_consumption_details_property.is_some() {
8744									return Err(<A::Error as de::Error>::duplicate_field(
8745										"hasEnergyConsumptionDetails",
8746									));
8747								}
8748								r#has_energy_consumption_details_property = Some({
8749									struct DeserializeWith(
8750										Vec<HasEnergyConsumptionDetailsProperty>,
8751									);
8752									impl<'de> Deserialize<'de> for DeserializeWith {
8753										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8754										where
8755											D: Deserializer<'de>,
8756										{
8757											Ok(DeserializeWith(serde_with::As::<
8758												serde_with::OneOrMany<serde_with::Same>,
8759											>::deserialize(deserializer)?))
8760										}
8761									}
8762									match map.next_value::<DeserializeWith>() {
8763										Ok(deserialize_with) => deserialize_with.0,
8764										Err(err) => {
8765											return Err(err);
8766										}
8767									}
8768								});
8769							}
8770							Field::HasMeasurement => {
8771								if r#has_measurement_property.is_some() {
8772									return Err(<A::Error as de::Error>::duplicate_field(
8773										"hasMeasurement",
8774									));
8775								}
8776								r#has_measurement_property = Some({
8777									struct DeserializeWith(Vec<HasMeasurementProperty>);
8778									impl<'de> Deserialize<'de> for DeserializeWith {
8779										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8780										where
8781											D: Deserializer<'de>,
8782										{
8783											Ok(DeserializeWith(serde_with::As::<
8784												serde_with::OneOrMany<serde_with::Same>,
8785											>::deserialize(deserializer)?))
8786										}
8787									}
8788									match map.next_value::<DeserializeWith>() {
8789										Ok(deserialize_with) => deserialize_with.0,
8790										Err(err) => {
8791											return Err(err);
8792										}
8793									}
8794								});
8795							}
8796							Field::HasMerchantReturnPolicy => {
8797								if r#has_merchant_return_policy_property.is_some() {
8798									return Err(<A::Error as de::Error>::duplicate_field(
8799										"hasMerchantReturnPolicy",
8800									));
8801								}
8802								r#has_merchant_return_policy_property = Some({
8803									struct DeserializeWith(Vec<HasMerchantReturnPolicyProperty>);
8804									impl<'de> Deserialize<'de> for DeserializeWith {
8805										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8806										where
8807											D: Deserializer<'de>,
8808										{
8809											Ok(DeserializeWith(serde_with::As::<
8810												serde_with::OneOrMany<serde_with::Same>,
8811											>::deserialize(deserializer)?))
8812										}
8813									}
8814									match map.next_value::<DeserializeWith>() {
8815										Ok(deserialize_with) => deserialize_with.0,
8816										Err(err) => {
8817											return Err(err);
8818										}
8819									}
8820								});
8821							}
8822							Field::HasProductReturnPolicy => {
8823								if r#has_product_return_policy_property.is_some() {
8824									return Err(<A::Error as de::Error>::duplicate_field(
8825										"hasProductReturnPolicy",
8826									));
8827								}
8828								r#has_product_return_policy_property = Some({
8829									struct DeserializeWith(Vec<HasProductReturnPolicyProperty>);
8830									impl<'de> Deserialize<'de> for DeserializeWith {
8831										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8832										where
8833											D: Deserializer<'de>,
8834										{
8835											Ok(DeserializeWith(serde_with::As::<
8836												serde_with::OneOrMany<serde_with::Same>,
8837											>::deserialize(deserializer)?))
8838										}
8839									}
8840									match map.next_value::<DeserializeWith>() {
8841										Ok(deserialize_with) => deserialize_with.0,
8842										Err(err) => {
8843											return Err(err);
8844										}
8845									}
8846								});
8847							}
8848							Field::Height => {
8849								if r#height_property.is_some() {
8850									return Err(<A::Error as de::Error>::duplicate_field("height"));
8851								}
8852								r#height_property = Some({
8853									struct DeserializeWith(Vec<HeightProperty>);
8854									impl<'de> Deserialize<'de> for DeserializeWith {
8855										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8856										where
8857											D: Deserializer<'de>,
8858										{
8859											Ok(DeserializeWith(serde_with::As::<
8860												serde_with::OneOrMany<serde_with::Same>,
8861											>::deserialize(deserializer)?))
8862										}
8863									}
8864									match map.next_value::<DeserializeWith>() {
8865										Ok(deserialize_with) => deserialize_with.0,
8866										Err(err) => {
8867											return Err(err);
8868										}
8869									}
8870								});
8871							}
8872							Field::InProductGroupWithId => {
8873								if r#in_product_group_with_id_property.is_some() {
8874									return Err(<A::Error as de::Error>::duplicate_field(
8875										"inProductGroupWithID",
8876									));
8877								}
8878								r#in_product_group_with_id_property = Some({
8879									struct DeserializeWith(Vec<InProductGroupWithIdProperty>);
8880									impl<'de> Deserialize<'de> for DeserializeWith {
8881										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8882										where
8883											D: Deserializer<'de>,
8884										{
8885											Ok(DeserializeWith(serde_with::As::<
8886												serde_with::OneOrMany<serde_with::Same>,
8887											>::deserialize(deserializer)?))
8888										}
8889									}
8890									match map.next_value::<DeserializeWith>() {
8891										Ok(deserialize_with) => deserialize_with.0,
8892										Err(err) => {
8893											return Err(err);
8894										}
8895									}
8896								});
8897							}
8898							Field::IsAccessoryOrSparePartFor => {
8899								if r#is_accessory_or_spare_part_for_property.is_some() {
8900									return Err(<A::Error as de::Error>::duplicate_field(
8901										"isAccessoryOrSparePartFor",
8902									));
8903								}
8904								r#is_accessory_or_spare_part_for_property = Some({
8905									struct DeserializeWith(Vec<IsAccessoryOrSparePartForProperty>);
8906									impl<'de> Deserialize<'de> for DeserializeWith {
8907										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8908										where
8909											D: Deserializer<'de>,
8910										{
8911											Ok(DeserializeWith(serde_with::As::<
8912												serde_with::OneOrMany<serde_with::Same>,
8913											>::deserialize(deserializer)?))
8914										}
8915									}
8916									match map.next_value::<DeserializeWith>() {
8917										Ok(deserialize_with) => deserialize_with.0,
8918										Err(err) => {
8919											return Err(err);
8920										}
8921									}
8922								});
8923							}
8924							Field::IsConsumableFor => {
8925								if r#is_consumable_for_property.is_some() {
8926									return Err(<A::Error as de::Error>::duplicate_field(
8927										"isConsumableFor",
8928									));
8929								}
8930								r#is_consumable_for_property = Some({
8931									struct DeserializeWith(Vec<IsConsumableForProperty>);
8932									impl<'de> Deserialize<'de> for DeserializeWith {
8933										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8934										where
8935											D: Deserializer<'de>,
8936										{
8937											Ok(DeserializeWith(serde_with::As::<
8938												serde_with::OneOrMany<serde_with::Same>,
8939											>::deserialize(deserializer)?))
8940										}
8941									}
8942									match map.next_value::<DeserializeWith>() {
8943										Ok(deserialize_with) => deserialize_with.0,
8944										Err(err) => {
8945											return Err(err);
8946										}
8947									}
8948								});
8949							}
8950							Field::IsRelatedTo => {
8951								if r#is_related_to_property.is_some() {
8952									return Err(<A::Error as de::Error>::duplicate_field(
8953										"isRelatedTo",
8954									));
8955								}
8956								r#is_related_to_property = Some({
8957									struct DeserializeWith(Vec<IsRelatedToProperty>);
8958									impl<'de> Deserialize<'de> for DeserializeWith {
8959										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8960										where
8961											D: Deserializer<'de>,
8962										{
8963											Ok(DeserializeWith(serde_with::As::<
8964												serde_with::OneOrMany<serde_with::Same>,
8965											>::deserialize(deserializer)?))
8966										}
8967									}
8968									match map.next_value::<DeserializeWith>() {
8969										Ok(deserialize_with) => deserialize_with.0,
8970										Err(err) => {
8971											return Err(err);
8972										}
8973									}
8974								});
8975							}
8976							Field::IsSimilarTo => {
8977								if r#is_similar_to_property.is_some() {
8978									return Err(<A::Error as de::Error>::duplicate_field(
8979										"isSimilarTo",
8980									));
8981								}
8982								r#is_similar_to_property = Some({
8983									struct DeserializeWith(Vec<IsSimilarToProperty>);
8984									impl<'de> Deserialize<'de> for DeserializeWith {
8985										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8986										where
8987											D: Deserializer<'de>,
8988										{
8989											Ok(DeserializeWith(serde_with::As::<
8990												serde_with::OneOrMany<serde_with::Same>,
8991											>::deserialize(deserializer)?))
8992										}
8993									}
8994									match map.next_value::<DeserializeWith>() {
8995										Ok(deserialize_with) => deserialize_with.0,
8996										Err(err) => {
8997											return Err(err);
8998										}
8999									}
9000								});
9001							}
9002							Field::IsVariantOf => {
9003								if r#is_variant_of_property.is_some() {
9004									return Err(<A::Error as de::Error>::duplicate_field(
9005										"isVariantOf",
9006									));
9007								}
9008								r#is_variant_of_property = Some({
9009									struct DeserializeWith(Vec<IsVariantOfProperty>);
9010									impl<'de> Deserialize<'de> for DeserializeWith {
9011										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9012										where
9013											D: Deserializer<'de>,
9014										{
9015											Ok(DeserializeWith(serde_with::As::<
9016												serde_with::OneOrMany<serde_with::Same>,
9017											>::deserialize(deserializer)?))
9018										}
9019									}
9020									match map.next_value::<DeserializeWith>() {
9021										Ok(deserialize_with) => deserialize_with.0,
9022										Err(err) => {
9023											return Err(err);
9024										}
9025									}
9026								});
9027							}
9028							Field::ItemCondition => {
9029								if r#item_condition_property.is_some() {
9030									return Err(<A::Error as de::Error>::duplicate_field(
9031										"itemCondition",
9032									));
9033								}
9034								r#item_condition_property = Some({
9035									struct DeserializeWith(Vec<ItemConditionProperty>);
9036									impl<'de> Deserialize<'de> for DeserializeWith {
9037										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9038										where
9039											D: Deserializer<'de>,
9040										{
9041											Ok(DeserializeWith(serde_with::As::<
9042												serde_with::OneOrMany<serde_with::Same>,
9043											>::deserialize(deserializer)?))
9044										}
9045									}
9046									match map.next_value::<DeserializeWith>() {
9047										Ok(deserialize_with) => deserialize_with.0,
9048										Err(err) => {
9049											return Err(err);
9050										}
9051									}
9052								});
9053							}
9054							Field::Logo => {
9055								if r#logo_property.is_some() {
9056									return Err(<A::Error as de::Error>::duplicate_field("logo"));
9057								}
9058								r#logo_property = Some({
9059									struct DeserializeWith(Vec<LogoProperty>);
9060									impl<'de> Deserialize<'de> for DeserializeWith {
9061										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9062										where
9063											D: Deserializer<'de>,
9064										{
9065											Ok(DeserializeWith(serde_with::As::<
9066												serde_with::OneOrMany<serde_with::Same>,
9067											>::deserialize(deserializer)?))
9068										}
9069									}
9070									match map.next_value::<DeserializeWith>() {
9071										Ok(deserialize_with) => deserialize_with.0,
9072										Err(err) => {
9073											return Err(err);
9074										}
9075									}
9076								});
9077							}
9078							Field::Manufacturer => {
9079								if r#manufacturer_property.is_some() {
9080									return Err(<A::Error as de::Error>::duplicate_field(
9081										"manufacturer",
9082									));
9083								}
9084								r#manufacturer_property = Some({
9085									struct DeserializeWith(Vec<ManufacturerProperty>);
9086									impl<'de> Deserialize<'de> for DeserializeWith {
9087										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9088										where
9089											D: Deserializer<'de>,
9090										{
9091											Ok(DeserializeWith(serde_with::As::<
9092												serde_with::OneOrMany<serde_with::Same>,
9093											>::deserialize(deserializer)?))
9094										}
9095									}
9096									match map.next_value::<DeserializeWith>() {
9097										Ok(deserialize_with) => deserialize_with.0,
9098										Err(err) => {
9099											return Err(err);
9100										}
9101									}
9102								});
9103							}
9104							Field::MobileUrl => {
9105								if r#mobile_url_property.is_some() {
9106									return Err(<A::Error as de::Error>::duplicate_field(
9107										"mobileUrl",
9108									));
9109								}
9110								r#mobile_url_property = Some({
9111									struct DeserializeWith(Vec<MobileUrlProperty>);
9112									impl<'de> Deserialize<'de> for DeserializeWith {
9113										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9114										where
9115											D: Deserializer<'de>,
9116										{
9117											Ok(DeserializeWith(serde_with::As::<
9118												serde_with::OneOrMany<serde_with::Same>,
9119											>::deserialize(deserializer)?))
9120										}
9121									}
9122									match map.next_value::<DeserializeWith>() {
9123										Ok(deserialize_with) => deserialize_with.0,
9124										Err(err) => {
9125											return Err(err);
9126										}
9127									}
9128								});
9129							}
9130							Field::Model => {
9131								if r#model_property.is_some() {
9132									return Err(<A::Error as de::Error>::duplicate_field("model"));
9133								}
9134								r#model_property = Some({
9135									struct DeserializeWith(Vec<ModelProperty>);
9136									impl<'de> Deserialize<'de> for DeserializeWith {
9137										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9138										where
9139											D: Deserializer<'de>,
9140										{
9141											Ok(DeserializeWith(serde_with::As::<
9142												serde_with::OneOrMany<serde_with::Same>,
9143											>::deserialize(deserializer)?))
9144										}
9145									}
9146									match map.next_value::<DeserializeWith>() {
9147										Ok(deserialize_with) => deserialize_with.0,
9148										Err(err) => {
9149											return Err(err);
9150										}
9151									}
9152								});
9153							}
9154							Field::Mpn => {
9155								if r#mpn_property.is_some() {
9156									return Err(<A::Error as de::Error>::duplicate_field("mpn"));
9157								}
9158								r#mpn_property = Some({
9159									struct DeserializeWith(Vec<MpnProperty>);
9160									impl<'de> Deserialize<'de> for DeserializeWith {
9161										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9162										where
9163											D: Deserializer<'de>,
9164										{
9165											Ok(DeserializeWith(serde_with::As::<
9166												serde_with::OneOrMany<serde_with::Same>,
9167											>::deserialize(deserializer)?))
9168										}
9169									}
9170									match map.next_value::<DeserializeWith>() {
9171										Ok(deserialize_with) => deserialize_with.0,
9172										Err(err) => {
9173											return Err(err);
9174										}
9175									}
9176								});
9177							}
9178							Field::NegativeNotes => {
9179								if r#negative_notes_property.is_some() {
9180									return Err(<A::Error as de::Error>::duplicate_field(
9181										"negativeNotes",
9182									));
9183								}
9184								r#negative_notes_property = Some({
9185									struct DeserializeWith(Vec<NegativeNotesProperty>);
9186									impl<'de> Deserialize<'de> for DeserializeWith {
9187										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9188										where
9189											D: Deserializer<'de>,
9190										{
9191											Ok(DeserializeWith(serde_with::As::<
9192												serde_with::OneOrMany<serde_with::Same>,
9193											>::deserialize(deserializer)?))
9194										}
9195									}
9196									match map.next_value::<DeserializeWith>() {
9197										Ok(deserialize_with) => deserialize_with.0,
9198										Err(err) => {
9199											return Err(err);
9200										}
9201									}
9202								});
9203							}
9204							Field::Nsn => {
9205								if r#nsn_property.is_some() {
9206									return Err(<A::Error as de::Error>::duplicate_field("nsn"));
9207								}
9208								r#nsn_property = Some({
9209									struct DeserializeWith(Vec<NsnProperty>);
9210									impl<'de> Deserialize<'de> for DeserializeWith {
9211										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9212										where
9213											D: Deserializer<'de>,
9214										{
9215											Ok(DeserializeWith(serde_with::As::<
9216												serde_with::OneOrMany<serde_with::Same>,
9217											>::deserialize(deserializer)?))
9218										}
9219									}
9220									match map.next_value::<DeserializeWith>() {
9221										Ok(deserialize_with) => deserialize_with.0,
9222										Err(err) => {
9223											return Err(err);
9224										}
9225									}
9226								});
9227							}
9228							Field::PositiveNotes => {
9229								if r#positive_notes_property.is_some() {
9230									return Err(<A::Error as de::Error>::duplicate_field(
9231										"positiveNotes",
9232									));
9233								}
9234								r#positive_notes_property = Some({
9235									struct DeserializeWith(Vec<PositiveNotesProperty>);
9236									impl<'de> Deserialize<'de> for DeserializeWith {
9237										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9238										where
9239											D: Deserializer<'de>,
9240										{
9241											Ok(DeserializeWith(serde_with::As::<
9242												serde_with::OneOrMany<serde_with::Same>,
9243											>::deserialize(deserializer)?))
9244										}
9245									}
9246									match map.next_value::<DeserializeWith>() {
9247										Ok(deserialize_with) => deserialize_with.0,
9248										Err(err) => {
9249											return Err(err);
9250										}
9251									}
9252								});
9253							}
9254							Field::ProductId => {
9255								if r#product_id_property.is_some() {
9256									return Err(<A::Error as de::Error>::duplicate_field(
9257										"productID",
9258									));
9259								}
9260								r#product_id_property = Some({
9261									struct DeserializeWith(Vec<ProductIdProperty>);
9262									impl<'de> Deserialize<'de> for DeserializeWith {
9263										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9264										where
9265											D: Deserializer<'de>,
9266										{
9267											Ok(DeserializeWith(serde_with::As::<
9268												serde_with::OneOrMany<serde_with::Same>,
9269											>::deserialize(deserializer)?))
9270										}
9271									}
9272									match map.next_value::<DeserializeWith>() {
9273										Ok(deserialize_with) => deserialize_with.0,
9274										Err(err) => {
9275											return Err(err);
9276										}
9277									}
9278								});
9279							}
9280							Field::ProductionDate => {
9281								if r#production_date_property.is_some() {
9282									return Err(<A::Error as de::Error>::duplicate_field(
9283										"productionDate",
9284									));
9285								}
9286								r#production_date_property = Some({
9287									struct DeserializeWith(Vec<ProductionDateProperty>);
9288									impl<'de> Deserialize<'de> for DeserializeWith {
9289										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9290										where
9291											D: Deserializer<'de>,
9292										{
9293											Ok(DeserializeWith(serde_with::As::<
9294												serde_with::OneOrMany<serde_with::Same>,
9295											>::deserialize(deserializer)?))
9296										}
9297									}
9298									match map.next_value::<DeserializeWith>() {
9299										Ok(deserialize_with) => deserialize_with.0,
9300										Err(err) => {
9301											return Err(err);
9302										}
9303									}
9304								});
9305							}
9306							Field::PurchaseDate => {
9307								if r#purchase_date_property.is_some() {
9308									return Err(<A::Error as de::Error>::duplicate_field(
9309										"purchaseDate",
9310									));
9311								}
9312								r#purchase_date_property = Some({
9313									struct DeserializeWith(Vec<PurchaseDateProperty>);
9314									impl<'de> Deserialize<'de> for DeserializeWith {
9315										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9316										where
9317											D: Deserializer<'de>,
9318										{
9319											Ok(DeserializeWith(serde_with::As::<
9320												serde_with::OneOrMany<serde_with::Same>,
9321											>::deserialize(deserializer)?))
9322										}
9323									}
9324									match map.next_value::<DeserializeWith>() {
9325										Ok(deserialize_with) => deserialize_with.0,
9326										Err(err) => {
9327											return Err(err);
9328										}
9329									}
9330								});
9331							}
9332							Field::ReleaseDate => {
9333								if r#release_date_property.is_some() {
9334									return Err(<A::Error as de::Error>::duplicate_field(
9335										"releaseDate",
9336									));
9337								}
9338								r#release_date_property = Some({
9339									struct DeserializeWith(Vec<ReleaseDateProperty>);
9340									impl<'de> Deserialize<'de> for DeserializeWith {
9341										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9342										where
9343											D: Deserializer<'de>,
9344										{
9345											Ok(DeserializeWith(serde_with::As::<
9346												serde_with::OneOrMany<serde_with::Same>,
9347											>::deserialize(deserializer)?))
9348										}
9349									}
9350									match map.next_value::<DeserializeWith>() {
9351										Ok(deserialize_with) => deserialize_with.0,
9352										Err(err) => {
9353											return Err(err);
9354										}
9355									}
9356								});
9357							}
9358							Field::Sku => {
9359								if r#sku_property.is_some() {
9360									return Err(<A::Error as de::Error>::duplicate_field("sku"));
9361								}
9362								r#sku_property = Some({
9363									struct DeserializeWith(Vec<SkuProperty>);
9364									impl<'de> Deserialize<'de> for DeserializeWith {
9365										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9366										where
9367											D: Deserializer<'de>,
9368										{
9369											Ok(DeserializeWith(serde_with::As::<
9370												serde_with::OneOrMany<serde_with::Same>,
9371											>::deserialize(deserializer)?))
9372										}
9373									}
9374									match map.next_value::<DeserializeWith>() {
9375										Ok(deserialize_with) => deserialize_with.0,
9376										Err(err) => {
9377											return Err(err);
9378										}
9379									}
9380								});
9381							}
9382							Field::Slogan => {
9383								if r#slogan_property.is_some() {
9384									return Err(<A::Error as de::Error>::duplicate_field("slogan"));
9385								}
9386								r#slogan_property = Some({
9387									struct DeserializeWith(Vec<SloganProperty>);
9388									impl<'de> Deserialize<'de> for DeserializeWith {
9389										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9390										where
9391											D: Deserializer<'de>,
9392										{
9393											Ok(DeserializeWith(serde_with::As::<
9394												serde_with::OneOrMany<serde_with::Same>,
9395											>::deserialize(deserializer)?))
9396										}
9397									}
9398									match map.next_value::<DeserializeWith>() {
9399										Ok(deserialize_with) => deserialize_with.0,
9400										Err(err) => {
9401											return Err(err);
9402										}
9403									}
9404								});
9405							}
9406							Field::Weight => {
9407								if r#weight_property.is_some() {
9408									return Err(<A::Error as de::Error>::duplicate_field("weight"));
9409								}
9410								r#weight_property = Some({
9411									struct DeserializeWith(Vec<WeightProperty>);
9412									impl<'de> Deserialize<'de> for DeserializeWith {
9413										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9414										where
9415											D: Deserializer<'de>,
9416										{
9417											Ok(DeserializeWith(serde_with::As::<
9418												serde_with::OneOrMany<serde_with::Same>,
9419											>::deserialize(deserializer)?))
9420										}
9421									}
9422									match map.next_value::<DeserializeWith>() {
9423										Ok(deserialize_with) => deserialize_with.0,
9424										Err(err) => {
9425											return Err(err);
9426										}
9427									}
9428								});
9429							}
9430							Field::Width => {
9431								if r#width_property.is_some() {
9432									return Err(<A::Error as de::Error>::duplicate_field("width"));
9433								}
9434								r#width_property = Some({
9435									struct DeserializeWith(Vec<WidthProperty>);
9436									impl<'de> Deserialize<'de> for DeserializeWith {
9437										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9438										where
9439											D: Deserializer<'de>,
9440										{
9441											Ok(DeserializeWith(serde_with::As::<
9442												serde_with::OneOrMany<serde_with::Same>,
9443											>::deserialize(deserializer)?))
9444										}
9445									}
9446									match map.next_value::<DeserializeWith>() {
9447										Ok(deserialize_with) => deserialize_with.0,
9448										Err(err) => {
9449											return Err(err);
9450										}
9451									}
9452								});
9453							}
9454							Field::AdditionalType => {
9455								if r#additional_type_property.is_some() {
9456									return Err(<A::Error as de::Error>::duplicate_field(
9457										"additionalType",
9458									));
9459								}
9460								r#additional_type_property = Some({
9461									struct DeserializeWith(Vec<AdditionalTypeProperty>);
9462									impl<'de> Deserialize<'de> for DeserializeWith {
9463										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9464										where
9465											D: Deserializer<'de>,
9466										{
9467											Ok(DeserializeWith(serde_with::As::<
9468												serde_with::OneOrMany<serde_with::Same>,
9469											>::deserialize(deserializer)?))
9470										}
9471									}
9472									match map.next_value::<DeserializeWith>() {
9473										Ok(deserialize_with) => deserialize_with.0,
9474										Err(err) => {
9475											return Err(err);
9476										}
9477									}
9478								});
9479							}
9480							Field::AlternateName => {
9481								if r#alternate_name_property.is_some() {
9482									return Err(<A::Error as de::Error>::duplicate_field(
9483										"alternateName",
9484									));
9485								}
9486								r#alternate_name_property = Some({
9487									struct DeserializeWith(Vec<AlternateNameProperty>);
9488									impl<'de> Deserialize<'de> for DeserializeWith {
9489										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9490										where
9491											D: Deserializer<'de>,
9492										{
9493											Ok(DeserializeWith(serde_with::As::<
9494												serde_with::OneOrMany<serde_with::Same>,
9495											>::deserialize(deserializer)?))
9496										}
9497									}
9498									match map.next_value::<DeserializeWith>() {
9499										Ok(deserialize_with) => deserialize_with.0,
9500										Err(err) => {
9501											return Err(err);
9502										}
9503									}
9504								});
9505							}
9506							Field::Description => {
9507								if r#description_property.is_some() {
9508									return Err(<A::Error as de::Error>::duplicate_field(
9509										"description",
9510									));
9511								}
9512								r#description_property = Some({
9513									struct DeserializeWith(Vec<DescriptionProperty>);
9514									impl<'de> Deserialize<'de> for DeserializeWith {
9515										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9516										where
9517											D: Deserializer<'de>,
9518										{
9519											Ok(DeserializeWith(serde_with::As::<
9520												serde_with::OneOrMany<serde_with::Same>,
9521											>::deserialize(deserializer)?))
9522										}
9523									}
9524									match map.next_value::<DeserializeWith>() {
9525										Ok(deserialize_with) => deserialize_with.0,
9526										Err(err) => {
9527											return Err(err);
9528										}
9529									}
9530								});
9531							}
9532							Field::DisambiguatingDescription => {
9533								if r#disambiguating_description_property.is_some() {
9534									return Err(<A::Error as de::Error>::duplicate_field(
9535										"disambiguatingDescription",
9536									));
9537								}
9538								r#disambiguating_description_property = Some({
9539									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
9540									impl<'de> Deserialize<'de> for DeserializeWith {
9541										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9542										where
9543											D: Deserializer<'de>,
9544										{
9545											Ok(DeserializeWith(serde_with::As::<
9546												serde_with::OneOrMany<serde_with::Same>,
9547											>::deserialize(deserializer)?))
9548										}
9549									}
9550									match map.next_value::<DeserializeWith>() {
9551										Ok(deserialize_with) => deserialize_with.0,
9552										Err(err) => {
9553											return Err(err);
9554										}
9555									}
9556								});
9557							}
9558							Field::Identifier => {
9559								if r#identifier_property.is_some() {
9560									return Err(<A::Error as de::Error>::duplicate_field(
9561										"identifier",
9562									));
9563								}
9564								r#identifier_property = Some({
9565									struct DeserializeWith(Vec<IdentifierProperty>);
9566									impl<'de> Deserialize<'de> for DeserializeWith {
9567										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9568										where
9569											D: Deserializer<'de>,
9570										{
9571											Ok(DeserializeWith(serde_with::As::<
9572												serde_with::OneOrMany<serde_with::Same>,
9573											>::deserialize(deserializer)?))
9574										}
9575									}
9576									match map.next_value::<DeserializeWith>() {
9577										Ok(deserialize_with) => deserialize_with.0,
9578										Err(err) => {
9579											return Err(err);
9580										}
9581									}
9582								});
9583							}
9584							Field::Image => {
9585								if r#image_property.is_some() {
9586									return Err(<A::Error as de::Error>::duplicate_field("image"));
9587								}
9588								r#image_property = Some({
9589									struct DeserializeWith(Vec<ImageProperty>);
9590									impl<'de> Deserialize<'de> for DeserializeWith {
9591										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9592										where
9593											D: Deserializer<'de>,
9594										{
9595											Ok(DeserializeWith(serde_with::As::<
9596												serde_with::OneOrMany<serde_with::Same>,
9597											>::deserialize(deserializer)?))
9598										}
9599									}
9600									match map.next_value::<DeserializeWith>() {
9601										Ok(deserialize_with) => deserialize_with.0,
9602										Err(err) => {
9603											return Err(err);
9604										}
9605									}
9606								});
9607							}
9608							Field::MainEntityOfPage => {
9609								if r#main_entity_of_page_property.is_some() {
9610									return Err(<A::Error as de::Error>::duplicate_field(
9611										"mainEntityOfPage",
9612									));
9613								}
9614								r#main_entity_of_page_property = Some({
9615									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
9616									impl<'de> Deserialize<'de> for DeserializeWith {
9617										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9618										where
9619											D: Deserializer<'de>,
9620										{
9621											Ok(DeserializeWith(serde_with::As::<
9622												serde_with::OneOrMany<serde_with::Same>,
9623											>::deserialize(deserializer)?))
9624										}
9625									}
9626									match map.next_value::<DeserializeWith>() {
9627										Ok(deserialize_with) => deserialize_with.0,
9628										Err(err) => {
9629											return Err(err);
9630										}
9631									}
9632								});
9633							}
9634							Field::Name => {
9635								if r#name_property.is_some() {
9636									return Err(<A::Error as de::Error>::duplicate_field("name"));
9637								}
9638								r#name_property = Some({
9639									struct DeserializeWith(Vec<NameProperty>);
9640									impl<'de> Deserialize<'de> for DeserializeWith {
9641										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9642										where
9643											D: Deserializer<'de>,
9644										{
9645											Ok(DeserializeWith(serde_with::As::<
9646												serde_with::OneOrMany<serde_with::Same>,
9647											>::deserialize(deserializer)?))
9648										}
9649									}
9650									match map.next_value::<DeserializeWith>() {
9651										Ok(deserialize_with) => deserialize_with.0,
9652										Err(err) => {
9653											return Err(err);
9654										}
9655									}
9656								});
9657							}
9658							Field::PotentialAction => {
9659								if r#potential_action_property.is_some() {
9660									return Err(<A::Error as de::Error>::duplicate_field(
9661										"potentialAction",
9662									));
9663								}
9664								r#potential_action_property = Some({
9665									struct DeserializeWith(Vec<PotentialActionProperty>);
9666									impl<'de> Deserialize<'de> for DeserializeWith {
9667										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9668										where
9669											D: Deserializer<'de>,
9670										{
9671											Ok(DeserializeWith(serde_with::As::<
9672												serde_with::OneOrMany<serde_with::Same>,
9673											>::deserialize(deserializer)?))
9674										}
9675									}
9676									match map.next_value::<DeserializeWith>() {
9677										Ok(deserialize_with) => deserialize_with.0,
9678										Err(err) => {
9679											return Err(err);
9680										}
9681									}
9682								});
9683							}
9684							Field::SameAs => {
9685								if r#same_as_property.is_some() {
9686									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
9687								}
9688								r#same_as_property = Some({
9689									struct DeserializeWith(Vec<SameAsProperty>);
9690									impl<'de> Deserialize<'de> for DeserializeWith {
9691										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9692										where
9693											D: Deserializer<'de>,
9694										{
9695											Ok(DeserializeWith(serde_with::As::<
9696												serde_with::OneOrMany<serde_with::Same>,
9697											>::deserialize(deserializer)?))
9698										}
9699									}
9700									match map.next_value::<DeserializeWith>() {
9701										Ok(deserialize_with) => deserialize_with.0,
9702										Err(err) => {
9703											return Err(err);
9704										}
9705									}
9706								});
9707							}
9708							Field::SubjectOf => {
9709								if r#subject_of_property.is_some() {
9710									return Err(<A::Error as de::Error>::duplicate_field(
9711										"subjectOf",
9712									));
9713								}
9714								r#subject_of_property = Some({
9715									struct DeserializeWith(Vec<SubjectOfProperty>);
9716									impl<'de> Deserialize<'de> for DeserializeWith {
9717										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9718										where
9719											D: Deserializer<'de>,
9720										{
9721											Ok(DeserializeWith(serde_with::As::<
9722												serde_with::OneOrMany<serde_with::Same>,
9723											>::deserialize(deserializer)?))
9724										}
9725									}
9726									match map.next_value::<DeserializeWith>() {
9727										Ok(deserialize_with) => deserialize_with.0,
9728										Err(err) => {
9729											return Err(err);
9730										}
9731									}
9732								});
9733							}
9734							Field::Url => {
9735								if r#url_property.is_some() {
9736									return Err(<A::Error as de::Error>::duplicate_field("url"));
9737								}
9738								r#url_property = Some({
9739									struct DeserializeWith(Vec<UrlProperty>);
9740									impl<'de> Deserialize<'de> for DeserializeWith {
9741										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9742										where
9743											D: Deserializer<'de>,
9744										{
9745											Ok(DeserializeWith(serde_with::As::<
9746												serde_with::OneOrMany<serde_with::Same>,
9747											>::deserialize(deserializer)?))
9748										}
9749									}
9750									match map.next_value::<DeserializeWith>() {
9751										Ok(deserialize_with) => deserialize_with.0,
9752										Err(err) => {
9753											return Err(err);
9754										}
9755									}
9756								});
9757							}
9758							Field::Ignore => {
9759								let _ = map.next_value::<de::IgnoredAny>()?;
9760							}
9761						}
9762					}
9763					Ok(ProductCollection {
9764						r#includes_object: r#includes_object_property.unwrap_or_default(),
9765						r#collection_size: r#collection_size_property.unwrap_or_default(),
9766						r#about: r#about_property.unwrap_or_default(),
9767						r#abstract: r#abstract_property.unwrap_or_default(),
9768						r#access_mode: r#access_mode_property.unwrap_or_default(),
9769						r#access_mode_sufficient: r#access_mode_sufficient_property
9770							.unwrap_or_default(),
9771						r#accessibility_api: r#accessibility_api_property.unwrap_or_default(),
9772						r#accessibility_control: r#accessibility_control_property
9773							.unwrap_or_default(),
9774						r#accessibility_feature: r#accessibility_feature_property
9775							.unwrap_or_default(),
9776						r#accessibility_hazard: r#accessibility_hazard_property.unwrap_or_default(),
9777						r#accessibility_summary: r#accessibility_summary_property
9778							.unwrap_or_default(),
9779						r#accountable_person: r#accountable_person_property.unwrap_or_default(),
9780						r#acquire_license_page: r#acquire_license_page_property.unwrap_or_default(),
9781						r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
9782						r#alternative_headline: r#alternative_headline_property.unwrap_or_default(),
9783						r#archived_at: r#archived_at_property.unwrap_or_default(),
9784						r#assesses: r#assesses_property.unwrap_or_default(),
9785						r#associated_media: r#associated_media_property.unwrap_or_default(),
9786						r#audience: r#audience_property.unwrap_or_default(),
9787						r#audio: r#audio_property.unwrap_or_default(),
9788						r#author: r#author_property.unwrap_or_default(),
9789						r#award: r#award_property.unwrap_or_default(),
9790						r#awards: r#awards_property.unwrap_or_default(),
9791						r#character: r#character_property.unwrap_or_default(),
9792						r#citation: r#citation_property.unwrap_or_default(),
9793						r#comment: r#comment_property.unwrap_or_default(),
9794						r#comment_count: r#comment_count_property.unwrap_or_default(),
9795						r#conditions_of_access: r#conditions_of_access_property.unwrap_or_default(),
9796						r#content_location: r#content_location_property.unwrap_or_default(),
9797						r#content_rating: r#content_rating_property.unwrap_or_default(),
9798						r#content_reference_time: r#content_reference_time_property
9799							.unwrap_or_default(),
9800						r#contributor: r#contributor_property.unwrap_or_default(),
9801						r#copyright_holder: r#copyright_holder_property.unwrap_or_default(),
9802						r#copyright_notice: r#copyright_notice_property.unwrap_or_default(),
9803						r#copyright_year: r#copyright_year_property.unwrap_or_default(),
9804						r#correction: r#correction_property.unwrap_or_default(),
9805						r#country_of_origin: r#country_of_origin_property.unwrap_or_default(),
9806						r#creative_work_status: r#creative_work_status_property.unwrap_or_default(),
9807						r#creator: r#creator_property.unwrap_or_default(),
9808						r#credit_text: r#credit_text_property.unwrap_or_default(),
9809						r#date_created: r#date_created_property.unwrap_or_default(),
9810						r#date_modified: r#date_modified_property.unwrap_or_default(),
9811						r#date_published: r#date_published_property.unwrap_or_default(),
9812						r#discussion_url: r#discussion_url_property.unwrap_or_default(),
9813						r#edit_eidr: r#edit_eidr_property.unwrap_or_default(),
9814						r#editor: r#editor_property.unwrap_or_default(),
9815						r#educational_alignment: r#educational_alignment_property
9816							.unwrap_or_default(),
9817						r#educational_level: r#educational_level_property.unwrap_or_default(),
9818						r#educational_use: r#educational_use_property.unwrap_or_default(),
9819						r#encoding: r#encoding_property.unwrap_or_default(),
9820						r#encoding_format: r#encoding_format_property.unwrap_or_default(),
9821						r#encodings: r#encodings_property.unwrap_or_default(),
9822						r#example_of_work: r#example_of_work_property.unwrap_or_default(),
9823						r#expires: r#expires_property.unwrap_or_default(),
9824						r#file_format: r#file_format_property.unwrap_or_default(),
9825						r#funder: r#funder_property.unwrap_or_default(),
9826						r#funding: r#funding_property.unwrap_or_default(),
9827						r#genre: r#genre_property.unwrap_or_default(),
9828						r#has_part: r#has_part_property.unwrap_or_default(),
9829						r#headline: r#headline_property.unwrap_or_default(),
9830						r#in_language: r#in_language_property.unwrap_or_default(),
9831						r#interaction_statistic: r#interaction_statistic_property
9832							.unwrap_or_default(),
9833						r#interactivity_type: r#interactivity_type_property.unwrap_or_default(),
9834						r#interpreted_as_claim: r#interpreted_as_claim_property.unwrap_or_default(),
9835						r#is_accessible_for_free: r#is_accessible_for_free_property
9836							.unwrap_or_default(),
9837						r#is_based_on: r#is_based_on_property.unwrap_or_default(),
9838						r#is_based_on_url: r#is_based_on_url_property.unwrap_or_default(),
9839						r#is_family_friendly: r#is_family_friendly_property.unwrap_or_default(),
9840						r#is_part_of: r#is_part_of_property.unwrap_or_default(),
9841						r#keywords: r#keywords_property.unwrap_or_default(),
9842						r#learning_resource_type: r#learning_resource_type_property
9843							.unwrap_or_default(),
9844						r#license: r#license_property.unwrap_or_default(),
9845						r#location_created: r#location_created_property.unwrap_or_default(),
9846						r#main_entity: r#main_entity_property.unwrap_or_default(),
9847						r#maintainer: r#maintainer_property.unwrap_or_default(),
9848						r#material: r#material_property.unwrap_or_default(),
9849						r#material_extent: r#material_extent_property.unwrap_or_default(),
9850						r#mentions: r#mentions_property.unwrap_or_default(),
9851						r#offers: r#offers_property.unwrap_or_default(),
9852						r#pattern: r#pattern_property.unwrap_or_default(),
9853						r#position: r#position_property.unwrap_or_default(),
9854						r#producer: r#producer_property.unwrap_or_default(),
9855						r#provider: r#provider_property.unwrap_or_default(),
9856						r#publication: r#publication_property.unwrap_or_default(),
9857						r#publisher: r#publisher_property.unwrap_or_default(),
9858						r#publisher_imprint: r#publisher_imprint_property.unwrap_or_default(),
9859						r#publishing_principles: r#publishing_principles_property
9860							.unwrap_or_default(),
9861						r#recorded_at: r#recorded_at_property.unwrap_or_default(),
9862						r#released_event: r#released_event_property.unwrap_or_default(),
9863						r#review: r#review_property.unwrap_or_default(),
9864						r#reviews: r#reviews_property.unwrap_or_default(),
9865						r#schema_version: r#schema_version_property.unwrap_or_default(),
9866						r#sd_date_published: r#sd_date_published_property.unwrap_or_default(),
9867						r#sd_license: r#sd_license_property.unwrap_or_default(),
9868						r#sd_publisher: r#sd_publisher_property.unwrap_or_default(),
9869						r#size: r#size_property.unwrap_or_default(),
9870						r#source_organization: r#source_organization_property.unwrap_or_default(),
9871						r#spatial: r#spatial_property.unwrap_or_default(),
9872						r#spatial_coverage: r#spatial_coverage_property.unwrap_or_default(),
9873						r#sponsor: r#sponsor_property.unwrap_or_default(),
9874						r#teaches: r#teaches_property.unwrap_or_default(),
9875						r#temporal: r#temporal_property.unwrap_or_default(),
9876						r#temporal_coverage: r#temporal_coverage_property.unwrap_or_default(),
9877						r#text: r#text_property.unwrap_or_default(),
9878						r#thumbnail: r#thumbnail_property.unwrap_or_default(),
9879						r#thumbnail_url: r#thumbnail_url_property.unwrap_or_default(),
9880						r#time_required: r#time_required_property.unwrap_or_default(),
9881						r#translation_of_work: r#translation_of_work_property.unwrap_or_default(),
9882						r#translator: r#translator_property.unwrap_or_default(),
9883						r#typical_age_range: r#typical_age_range_property.unwrap_or_default(),
9884						r#usage_info: r#usage_info_property.unwrap_or_default(),
9885						r#version: r#version_property.unwrap_or_default(),
9886						r#video: r#video_property.unwrap_or_default(),
9887						r#work_example: r#work_example_property.unwrap_or_default(),
9888						r#work_translation: r#work_translation_property.unwrap_or_default(),
9889						r#additional_property: r#additional_property_property.unwrap_or_default(),
9890						r#asin: r#asin_property.unwrap_or_default(),
9891						r#brand: r#brand_property.unwrap_or_default(),
9892						r#category: r#category_property.unwrap_or_default(),
9893						r#color: r#color_property.unwrap_or_default(),
9894						r#country_of_assembly: r#country_of_assembly_property.unwrap_or_default(),
9895						r#country_of_last_processing: r#country_of_last_processing_property
9896							.unwrap_or_default(),
9897						r#depth: r#depth_property.unwrap_or_default(),
9898						r#gtin: r#gtin_property.unwrap_or_default(),
9899						r#gtin_12: r#gtin_12_property.unwrap_or_default(),
9900						r#gtin_13: r#gtin_13_property.unwrap_or_default(),
9901						r#gtin_14: r#gtin_14_property.unwrap_or_default(),
9902						r#gtin_8: r#gtin_8_property.unwrap_or_default(),
9903						r#has_adult_consideration: r#has_adult_consideration_property
9904							.unwrap_or_default(),
9905						r#has_energy_consumption_details: r#has_energy_consumption_details_property
9906							.unwrap_or_default(),
9907						r#has_measurement: r#has_measurement_property.unwrap_or_default(),
9908						r#has_merchant_return_policy: r#has_merchant_return_policy_property
9909							.unwrap_or_default(),
9910						r#has_product_return_policy: r#has_product_return_policy_property
9911							.unwrap_or_default(),
9912						r#height: r#height_property.unwrap_or_default(),
9913						r#in_product_group_with_id: r#in_product_group_with_id_property
9914							.unwrap_or_default(),
9915						r#is_accessory_or_spare_part_for: r#is_accessory_or_spare_part_for_property
9916							.unwrap_or_default(),
9917						r#is_consumable_for: r#is_consumable_for_property.unwrap_or_default(),
9918						r#is_related_to: r#is_related_to_property.unwrap_or_default(),
9919						r#is_similar_to: r#is_similar_to_property.unwrap_or_default(),
9920						r#is_variant_of: r#is_variant_of_property.unwrap_or_default(),
9921						r#item_condition: r#item_condition_property.unwrap_or_default(),
9922						r#logo: r#logo_property.unwrap_or_default(),
9923						r#manufacturer: r#manufacturer_property.unwrap_or_default(),
9924						r#mobile_url: r#mobile_url_property.unwrap_or_default(),
9925						r#model: r#model_property.unwrap_or_default(),
9926						r#mpn: r#mpn_property.unwrap_or_default(),
9927						r#negative_notes: r#negative_notes_property.unwrap_or_default(),
9928						r#nsn: r#nsn_property.unwrap_or_default(),
9929						r#positive_notes: r#positive_notes_property.unwrap_or_default(),
9930						r#product_id: r#product_id_property.unwrap_or_default(),
9931						r#production_date: r#production_date_property.unwrap_or_default(),
9932						r#purchase_date: r#purchase_date_property.unwrap_or_default(),
9933						r#release_date: r#release_date_property.unwrap_or_default(),
9934						r#sku: r#sku_property.unwrap_or_default(),
9935						r#slogan: r#slogan_property.unwrap_or_default(),
9936						r#weight: r#weight_property.unwrap_or_default(),
9937						r#width: r#width_property.unwrap_or_default(),
9938						r#additional_type: r#additional_type_property.unwrap_or_default(),
9939						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
9940						r#description: r#description_property.unwrap_or_default(),
9941						r#disambiguating_description: r#disambiguating_description_property
9942							.unwrap_or_default(),
9943						r#identifier: r#identifier_property.unwrap_or_default(),
9944						r#image: r#image_property.unwrap_or_default(),
9945						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
9946						r#name: r#name_property.unwrap_or_default(),
9947						r#potential_action: r#potential_action_property.unwrap_or_default(),
9948						r#same_as: r#same_as_property.unwrap_or_default(),
9949						r#subject_of: r#subject_of_property.unwrap_or_default(),
9950						r#url: r#url_property.unwrap_or_default(),
9951					})
9952				}
9953			}
9954			const FIELDS: &[&str] = &[
9955				"includesObject",
9956				"collectionSize",
9957				"about",
9958				"abstract",
9959				"accessMode",
9960				"accessModeSufficient",
9961				"accessibilityAPI",
9962				"accessibilityControl",
9963				"accessibilityFeature",
9964				"accessibilityHazard",
9965				"accessibilitySummary",
9966				"accountablePerson",
9967				"acquireLicensePage",
9968				"aggregateRating",
9969				"alternativeHeadline",
9970				"archivedAt",
9971				"assesses",
9972				"associatedMedia",
9973				"audience",
9974				"audio",
9975				"author",
9976				"award",
9977				"awards",
9978				"character",
9979				"citation",
9980				"comment",
9981				"commentCount",
9982				"conditionsOfAccess",
9983				"contentLocation",
9984				"contentRating",
9985				"contentReferenceTime",
9986				"contributor",
9987				"copyrightHolder",
9988				"copyrightNotice",
9989				"copyrightYear",
9990				"correction",
9991				"countryOfOrigin",
9992				"creativeWorkStatus",
9993				"creator",
9994				"creditText",
9995				"dateCreated",
9996				"dateModified",
9997				"datePublished",
9998				"discussionUrl",
9999				"editEIDR",
10000				"editor",
10001				"educationalAlignment",
10002				"educationalLevel",
10003				"educationalUse",
10004				"encoding",
10005				"encodingFormat",
10006				"encodings",
10007				"exampleOfWork",
10008				"expires",
10009				"fileFormat",
10010				"funder",
10011				"funding",
10012				"genre",
10013				"hasPart",
10014				"headline",
10015				"inLanguage",
10016				"interactionStatistic",
10017				"interactivityType",
10018				"interpretedAsClaim",
10019				"isAccessibleForFree",
10020				"isBasedOn",
10021				"isBasedOnUrl",
10022				"isFamilyFriendly",
10023				"isPartOf",
10024				"keywords",
10025				"learningResourceType",
10026				"license",
10027				"locationCreated",
10028				"mainEntity",
10029				"maintainer",
10030				"material",
10031				"materialExtent",
10032				"mentions",
10033				"offers",
10034				"pattern",
10035				"position",
10036				"producer",
10037				"provider",
10038				"publication",
10039				"publisher",
10040				"publisherImprint",
10041				"publishingPrinciples",
10042				"recordedAt",
10043				"releasedEvent",
10044				"review",
10045				"reviews",
10046				"schemaVersion",
10047				"sdDatePublished",
10048				"sdLicense",
10049				"sdPublisher",
10050				"size",
10051				"sourceOrganization",
10052				"spatial",
10053				"spatialCoverage",
10054				"sponsor",
10055				"teaches",
10056				"temporal",
10057				"temporalCoverage",
10058				"text",
10059				"thumbnail",
10060				"thumbnailUrl",
10061				"timeRequired",
10062				"translationOfWork",
10063				"translator",
10064				"typicalAgeRange",
10065				"usageInfo",
10066				"version",
10067				"video",
10068				"workExample",
10069				"workTranslation",
10070				"additionalProperty",
10071				"asin",
10072				"brand",
10073				"category",
10074				"color",
10075				"countryOfAssembly",
10076				"countryOfLastProcessing",
10077				"depth",
10078				"gtin",
10079				"gtin12",
10080				"gtin13",
10081				"gtin14",
10082				"gtin8",
10083				"hasAdultConsideration",
10084				"hasEnergyConsumptionDetails",
10085				"hasMeasurement",
10086				"hasMerchantReturnPolicy",
10087				"hasProductReturnPolicy",
10088				"height",
10089				"inProductGroupWithID",
10090				"isAccessoryOrSparePartFor",
10091				"isConsumableFor",
10092				"isRelatedTo",
10093				"isSimilarTo",
10094				"isVariantOf",
10095				"itemCondition",
10096				"logo",
10097				"manufacturer",
10098				"mobileUrl",
10099				"model",
10100				"mpn",
10101				"negativeNotes",
10102				"nsn",
10103				"positiveNotes",
10104				"productID",
10105				"productionDate",
10106				"purchaseDate",
10107				"releaseDate",
10108				"sku",
10109				"slogan",
10110				"weight",
10111				"width",
10112				"additionalType",
10113				"alternateName",
10114				"description",
10115				"disambiguatingDescription",
10116				"identifier",
10117				"image",
10118				"mainEntityOfPage",
10119				"name",
10120				"potentialAction",
10121				"sameAs",
10122				"subjectOf",
10123				"url",
10124			];
10125			deserializer.deserialize_struct("ProductCollection", FIELDS, ClassVisitor)
10126		}
10127	}
10128}
schema_org_types/schemas/classes/product_collection.rs

schema_org_types/schemas/classes/
product_collection.rs
