schema_org_types/schemas/classes/
review_news_article.rs

1use super::*;
2/// <https://schema.org/ReviewNewsArticle>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct ReviewNewsArticle {
6	/// <https://schema.org/articleBody>
7	pub r#article_body: Vec<ArticleBodyProperty>,
8	/// <https://schema.org/articleSection>
9	pub r#article_section: Vec<ArticleSectionProperty>,
10	/// <https://schema.org/backstory>
11	pub r#backstory: Vec<BackstoryProperty>,
12	/// <https://schema.org/pageEnd>
13	pub r#page_end: Vec<PageEndProperty>,
14	/// <https://schema.org/pageStart>
15	pub r#page_start: Vec<PageStartProperty>,
16	/// <https://schema.org/pagination>
17	pub r#pagination: Vec<PaginationProperty>,
18	/// <https://schema.org/speakable>
19	pub r#speakable: Vec<SpeakableProperty>,
20	/// <https://schema.org/wordCount>
21	pub r#word_count: Vec<WordCountProperty>,
22	/// <https://schema.org/about>
23	pub r#about: Vec<AboutProperty>,
24	/// <https://schema.org/abstract>
25	pub r#abstract: Vec<AbstractProperty>,
26	/// <https://schema.org/accessMode>
27	pub r#access_mode: Vec<AccessModeProperty>,
28	/// <https://schema.org/accessModeSufficient>
29	pub r#access_mode_sufficient: Vec<AccessModeSufficientProperty>,
30	/// <https://schema.org/accessibilityAPI>
31	pub r#accessibility_api: Vec<AccessibilityApiProperty>,
32	/// <https://schema.org/accessibilityControl>
33	pub r#accessibility_control: Vec<AccessibilityControlProperty>,
34	/// <https://schema.org/accessibilityFeature>
35	pub r#accessibility_feature: Vec<AccessibilityFeatureProperty>,
36	/// <https://schema.org/accessibilityHazard>
37	pub r#accessibility_hazard: Vec<AccessibilityHazardProperty>,
38	/// <https://schema.org/accessibilitySummary>
39	pub r#accessibility_summary: Vec<AccessibilitySummaryProperty>,
40	/// <https://schema.org/accountablePerson>
41	pub r#accountable_person: Vec<AccountablePersonProperty>,
42	/// <https://schema.org/acquireLicensePage>
43	pub r#acquire_license_page: Vec<AcquireLicensePageProperty>,
44	/// <https://schema.org/aggregateRating>
45	pub r#aggregate_rating: Vec<AggregateRatingProperty>,
46	/// <https://schema.org/alternativeHeadline>
47	pub r#alternative_headline: Vec<AlternativeHeadlineProperty>,
48	/// <https://schema.org/archivedAt>
49	pub r#archived_at: Vec<ArchivedAtProperty>,
50	/// <https://schema.org/assesses>
51	pub r#assesses: Vec<AssessesProperty>,
52	/// <https://schema.org/associatedMedia>
53	pub r#associated_media: Vec<AssociatedMediaProperty>,
54	/// <https://schema.org/audience>
55	pub r#audience: Vec<AudienceProperty>,
56	/// <https://schema.org/audio>
57	pub r#audio: Vec<AudioProperty>,
58	/// <https://schema.org/author>
59	pub r#author: Vec<AuthorProperty>,
60	/// <https://schema.org/award>
61	pub r#award: Vec<AwardProperty>,
62	/// <https://schema.org/awards>
63	#[deprecated = "This schema is superseded by <https://schema.org/award>."]
64	pub r#awards: Vec<AwardsProperty>,
65	/// <https://schema.org/character>
66	pub r#character: Vec<CharacterProperty>,
67	/// <https://schema.org/citation>
68	pub r#citation: Vec<CitationProperty>,
69	/// <https://schema.org/comment>
70	pub r#comment: Vec<CommentProperty>,
71	/// <https://schema.org/commentCount>
72	pub r#comment_count: Vec<CommentCountProperty>,
73	/// <https://schema.org/conditionsOfAccess>
74	pub r#conditions_of_access: Vec<ConditionsOfAccessProperty>,
75	/// <https://schema.org/contentLocation>
76	pub r#content_location: Vec<ContentLocationProperty>,
77	/// <https://schema.org/contentRating>
78	pub r#content_rating: Vec<ContentRatingProperty>,
79	/// <https://schema.org/contentReferenceTime>
80	pub r#content_reference_time: Vec<ContentReferenceTimeProperty>,
81	/// <https://schema.org/contributor>
82	pub r#contributor: Vec<ContributorProperty>,
83	/// <https://schema.org/copyrightHolder>
84	pub r#copyright_holder: Vec<CopyrightHolderProperty>,
85	/// <https://schema.org/copyrightNotice>
86	pub r#copyright_notice: Vec<CopyrightNoticeProperty>,
87	/// <https://schema.org/copyrightYear>
88	pub r#copyright_year: Vec<CopyrightYearProperty>,
89	/// <https://schema.org/correction>
90	pub r#correction: Vec<CorrectionProperty>,
91	/// <https://schema.org/countryOfOrigin>
92	pub r#country_of_origin: Vec<CountryOfOriginProperty>,
93	/// <https://schema.org/creativeWorkStatus>
94	pub r#creative_work_status: Vec<CreativeWorkStatusProperty>,
95	/// <https://schema.org/creator>
96	pub r#creator: Vec<CreatorProperty>,
97	/// <https://schema.org/creditText>
98	pub r#credit_text: Vec<CreditTextProperty>,
99	/// <https://schema.org/dateCreated>
100	pub r#date_created: Vec<DateCreatedProperty>,
101	/// <https://schema.org/dateModified>
102	pub r#date_modified: Vec<DateModifiedProperty>,
103	/// <https://schema.org/datePublished>
104	pub r#date_published: Vec<DatePublishedProperty>,
105	/// <https://schema.org/discussionUrl>
106	pub r#discussion_url: Vec<DiscussionUrlProperty>,
107	/// <https://schema.org/editEIDR>
108	pub r#edit_eidr: Vec<EditEidrProperty>,
109	/// <https://schema.org/editor>
110	pub r#editor: Vec<EditorProperty>,
111	/// <https://schema.org/educationalAlignment>
112	pub r#educational_alignment: Vec<EducationalAlignmentProperty>,
113	/// <https://schema.org/educationalLevel>
114	pub r#educational_level: Vec<EducationalLevelProperty>,
115	/// <https://schema.org/educationalUse>
116	pub r#educational_use: Vec<EducationalUseProperty>,
117	/// <https://schema.org/encoding>
118	pub r#encoding: Vec<EncodingProperty>,
119	/// <https://schema.org/encodingFormat>
120	pub r#encoding_format: Vec<EncodingFormatProperty>,
121	/// <https://schema.org/encodings>
122	#[deprecated = "This schema is superseded by <https://schema.org/encoding>."]
123	pub r#encodings: Vec<EncodingsProperty>,
124	/// <https://schema.org/exampleOfWork>
125	pub r#example_of_work: Vec<ExampleOfWorkProperty>,
126	/// <https://schema.org/expires>
127	pub r#expires: Vec<ExpiresProperty>,
128	/// <https://schema.org/fileFormat>
129	#[deprecated = "This schema is superseded by <https://schema.org/encodingFormat>."]
130	pub r#file_format: Vec<FileFormatProperty>,
131	/// <https://schema.org/funder>
132	pub r#funder: Vec<FunderProperty>,
133	/// <https://schema.org/funding>
134	pub r#funding: Vec<FundingProperty>,
135	/// <https://schema.org/genre>
136	pub r#genre: Vec<GenreProperty>,
137	/// <https://schema.org/hasPart>
138	pub r#has_part: Vec<HasPartProperty>,
139	/// <https://schema.org/headline>
140	pub r#headline: Vec<HeadlineProperty>,
141	/// <https://schema.org/inLanguage>
142	pub r#in_language: Vec<InLanguageProperty>,
143	/// <https://schema.org/interactionStatistic>
144	pub r#interaction_statistic: Vec<InteractionStatisticProperty>,
145	/// <https://schema.org/interactivityType>
146	pub r#interactivity_type: Vec<InteractivityTypeProperty>,
147	/// <https://schema.org/interpretedAsClaim>
148	pub r#interpreted_as_claim: Vec<InterpretedAsClaimProperty>,
149	/// <https://schema.org/isAccessibleForFree>
150	pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
151	/// <https://schema.org/isBasedOn>
152	pub r#is_based_on: Vec<IsBasedOnProperty>,
153	/// <https://schema.org/isBasedOnUrl>
154	#[deprecated = "This schema is superseded by <https://schema.org/isBasedOn>."]
155	pub r#is_based_on_url: Vec<IsBasedOnUrlProperty>,
156	/// <https://schema.org/isFamilyFriendly>
157	pub r#is_family_friendly: Vec<IsFamilyFriendlyProperty>,
158	/// <https://schema.org/isPartOf>
159	pub r#is_part_of: Vec<IsPartOfProperty>,
160	/// <https://schema.org/keywords>
161	pub r#keywords: Vec<KeywordsProperty>,
162	/// <https://schema.org/learningResourceType>
163	pub r#learning_resource_type: Vec<LearningResourceTypeProperty>,
164	/// <https://schema.org/license>
165	pub r#license: Vec<LicenseProperty>,
166	/// <https://schema.org/locationCreated>
167	pub r#location_created: Vec<LocationCreatedProperty>,
168	/// <https://schema.org/mainEntity>
169	pub r#main_entity: Vec<MainEntityProperty>,
170	/// <https://schema.org/maintainer>
171	pub r#maintainer: Vec<MaintainerProperty>,
172	/// <https://schema.org/material>
173	pub r#material: Vec<MaterialProperty>,
174	/// <https://schema.org/materialExtent>
175	pub r#material_extent: Vec<MaterialExtentProperty>,
176	/// <https://schema.org/mentions>
177	pub r#mentions: Vec<MentionsProperty>,
178	/// <https://schema.org/offers>
179	pub r#offers: Vec<OffersProperty>,
180	/// <https://schema.org/pattern>
181	pub r#pattern: Vec<PatternProperty>,
182	/// <https://schema.org/position>
183	pub r#position: Vec<PositionProperty>,
184	/// <https://schema.org/producer>
185	pub r#producer: Vec<ProducerProperty>,
186	/// <https://schema.org/provider>
187	pub r#provider: Vec<ProviderProperty>,
188	/// <https://schema.org/publication>
189	pub r#publication: Vec<PublicationProperty>,
190	/// <https://schema.org/publisher>
191	pub r#publisher: Vec<PublisherProperty>,
192	/// <https://schema.org/publisherImprint>
193	pub r#publisher_imprint: Vec<PublisherImprintProperty>,
194	/// <https://schema.org/publishingPrinciples>
195	pub r#publishing_principles: Vec<PublishingPrinciplesProperty>,
196	/// <https://schema.org/recordedAt>
197	pub r#recorded_at: Vec<RecordedAtProperty>,
198	/// <https://schema.org/releasedEvent>
199	pub r#released_event: Vec<ReleasedEventProperty>,
200	/// <https://schema.org/review>
201	pub r#review: Vec<ReviewProperty>,
202	/// <https://schema.org/reviews>
203	#[deprecated = "This schema is superseded by <https://schema.org/review>."]
204	pub r#reviews: Vec<ReviewsProperty>,
205	/// <https://schema.org/schemaVersion>
206	pub r#schema_version: Vec<SchemaVersionProperty>,
207	/// <https://schema.org/sdDatePublished>
208	pub r#sd_date_published: Vec<SdDatePublishedProperty>,
209	/// <https://schema.org/sdLicense>
210	pub r#sd_license: Vec<SdLicenseProperty>,
211	/// <https://schema.org/sdPublisher>
212	pub r#sd_publisher: Vec<SdPublisherProperty>,
213	/// <https://schema.org/size>
214	pub r#size: Vec<SizeProperty>,
215	/// <https://schema.org/sourceOrganization>
216	pub r#source_organization: Vec<SourceOrganizationProperty>,
217	/// <https://schema.org/spatial>
218	pub r#spatial: Vec<SpatialProperty>,
219	/// <https://schema.org/spatialCoverage>
220	pub r#spatial_coverage: Vec<SpatialCoverageProperty>,
221	/// <https://schema.org/sponsor>
222	pub r#sponsor: Vec<SponsorProperty>,
223	/// <https://schema.org/teaches>
224	pub r#teaches: Vec<TeachesProperty>,
225	/// <https://schema.org/temporal>
226	pub r#temporal: Vec<TemporalProperty>,
227	/// <https://schema.org/temporalCoverage>
228	pub r#temporal_coverage: Vec<TemporalCoverageProperty>,
229	/// <https://schema.org/text>
230	pub r#text: Vec<TextProperty>,
231	/// <https://schema.org/thumbnail>
232	pub r#thumbnail: Vec<ThumbnailProperty>,
233	/// <https://schema.org/thumbnailUrl>
234	pub r#thumbnail_url: Vec<ThumbnailUrlProperty>,
235	/// <https://schema.org/timeRequired>
236	pub r#time_required: Vec<TimeRequiredProperty>,
237	/// <https://schema.org/translationOfWork>
238	pub r#translation_of_work: Vec<TranslationOfWorkProperty>,
239	/// <https://schema.org/translator>
240	pub r#translator: Vec<TranslatorProperty>,
241	/// <https://schema.org/typicalAgeRange>
242	pub r#typical_age_range: Vec<TypicalAgeRangeProperty>,
243	/// <https://schema.org/usageInfo>
244	pub r#usage_info: Vec<UsageInfoProperty>,
245	/// <https://schema.org/version>
246	pub r#version: Vec<VersionProperty>,
247	/// <https://schema.org/video>
248	pub r#video: Vec<VideoProperty>,
249	/// <https://schema.org/workExample>
250	pub r#work_example: Vec<WorkExampleProperty>,
251	/// <https://schema.org/workTranslation>
252	pub r#work_translation: Vec<WorkTranslationProperty>,
253	/// <https://schema.org/dateline>
254	pub r#dateline: Vec<DatelineProperty>,
255	/// <https://schema.org/printColumn>
256	pub r#print_column: Vec<PrintColumnProperty>,
257	/// <https://schema.org/printEdition>
258	pub r#print_edition: Vec<PrintEditionProperty>,
259	/// <https://schema.org/printPage>
260	pub r#print_page: Vec<PrintPageProperty>,
261	/// <https://schema.org/printSection>
262	pub r#print_section: Vec<PrintSectionProperty>,
263	/// <https://schema.org/associatedClaimReview>
264	pub r#associated_claim_review: Vec<AssociatedClaimReviewProperty>,
265	/// <https://schema.org/associatedMediaReview>
266	pub r#associated_media_review: Vec<AssociatedMediaReviewProperty>,
267	/// <https://schema.org/associatedReview>
268	pub r#associated_review: Vec<AssociatedReviewProperty>,
269	/// <https://schema.org/itemReviewed>
270	pub r#item_reviewed: Vec<ItemReviewedProperty>,
271	/// <https://schema.org/negativeNotes>
272	pub r#negative_notes: Vec<NegativeNotesProperty>,
273	/// <https://schema.org/positiveNotes>
274	pub r#positive_notes: Vec<PositiveNotesProperty>,
275	/// <https://schema.org/reviewAspect>
276	pub r#review_aspect: Vec<ReviewAspectProperty>,
277	/// <https://schema.org/reviewBody>
278	pub r#review_body: Vec<ReviewBodyProperty>,
279	/// <https://schema.org/reviewRating>
280	pub r#review_rating: Vec<ReviewRatingProperty>,
281	/// <https://schema.org/additionalType>
282	pub r#additional_type: Vec<AdditionalTypeProperty>,
283	/// <https://schema.org/alternateName>
284	pub r#alternate_name: Vec<AlternateNameProperty>,
285	/// <https://schema.org/description>
286	pub r#description: Vec<DescriptionProperty>,
287	/// <https://schema.org/disambiguatingDescription>
288	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
289	/// <https://schema.org/identifier>
290	pub r#identifier: Vec<IdentifierProperty>,
291	/// <https://schema.org/image>
292	pub r#image: Vec<ImageProperty>,
293	/// <https://schema.org/mainEntityOfPage>
294	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
295	/// <https://schema.org/name>
296	pub r#name: Vec<NameProperty>,
297	/// <https://schema.org/potentialAction>
298	pub r#potential_action: Vec<PotentialActionProperty>,
299	/// <https://schema.org/sameAs>
300	pub r#same_as: Vec<SameAsProperty>,
301	/// <https://schema.org/subjectOf>
302	pub r#subject_of: Vec<SubjectOfProperty>,
303	/// <https://schema.org/url>
304	pub r#url: Vec<UrlProperty>,
305}
306/// This trait is for properties from <https://schema.org/ReviewNewsArticle>.
307pub trait ReviewNewsArticleTrait {}
308impl ReviewNewsArticleTrait for ReviewNewsArticle {}
309impl ArticleTrait for ReviewNewsArticle {
310	fn get_article_body(&self) -> &[ArticleBodyProperty] {
311		self.r#article_body.as_slice()
312	}
313	fn take_article_body(&mut self) -> Vec<ArticleBodyProperty> {
314		std::mem::take(&mut self.r#article_body)
315	}
316	fn get_article_section(&self) -> &[ArticleSectionProperty] {
317		self.r#article_section.as_slice()
318	}
319	fn take_article_section(&mut self) -> Vec<ArticleSectionProperty> {
320		std::mem::take(&mut self.r#article_section)
321	}
322	fn get_backstory(&self) -> &[BackstoryProperty] {
323		self.r#backstory.as_slice()
324	}
325	fn take_backstory(&mut self) -> Vec<BackstoryProperty> {
326		std::mem::take(&mut self.r#backstory)
327	}
328	fn get_page_end(&self) -> &[PageEndProperty] {
329		self.r#page_end.as_slice()
330	}
331	fn take_page_end(&mut self) -> Vec<PageEndProperty> {
332		std::mem::take(&mut self.r#page_end)
333	}
334	fn get_page_start(&self) -> &[PageStartProperty] {
335		self.r#page_start.as_slice()
336	}
337	fn take_page_start(&mut self) -> Vec<PageStartProperty> {
338		std::mem::take(&mut self.r#page_start)
339	}
340	fn get_pagination(&self) -> &[PaginationProperty] {
341		self.r#pagination.as_slice()
342	}
343	fn take_pagination(&mut self) -> Vec<PaginationProperty> {
344		std::mem::take(&mut self.r#pagination)
345	}
346	fn get_speakable(&self) -> &[SpeakableProperty] {
347		self.r#speakable.as_slice()
348	}
349	fn take_speakable(&mut self) -> Vec<SpeakableProperty> {
350		std::mem::take(&mut self.r#speakable)
351	}
352	fn get_word_count(&self) -> &[WordCountProperty] {
353		self.r#word_count.as_slice()
354	}
355	fn take_word_count(&mut self) -> Vec<WordCountProperty> {
356		std::mem::take(&mut self.r#word_count)
357	}
358}
359impl CreativeWorkTrait for ReviewNewsArticle {
360	fn get_about(&self) -> &[AboutProperty] {
361		self.r#about.as_slice()
362	}
363	fn take_about(&mut self) -> Vec<AboutProperty> {
364		std::mem::take(&mut self.r#about)
365	}
366	fn get_abstract(&self) -> &[AbstractProperty] {
367		self.r#abstract.as_slice()
368	}
369	fn take_abstract(&mut self) -> Vec<AbstractProperty> {
370		std::mem::take(&mut self.r#abstract)
371	}
372	fn get_access_mode(&self) -> &[AccessModeProperty] {
373		self.r#access_mode.as_slice()
374	}
375	fn take_access_mode(&mut self) -> Vec<AccessModeProperty> {
376		std::mem::take(&mut self.r#access_mode)
377	}
378	fn get_access_mode_sufficient(&self) -> &[AccessModeSufficientProperty] {
379		self.r#access_mode_sufficient.as_slice()
380	}
381	fn take_access_mode_sufficient(&mut self) -> Vec<AccessModeSufficientProperty> {
382		std::mem::take(&mut self.r#access_mode_sufficient)
383	}
384	fn get_accessibility_api(&self) -> &[AccessibilityApiProperty] {
385		self.r#accessibility_api.as_slice()
386	}
387	fn take_accessibility_api(&mut self) -> Vec<AccessibilityApiProperty> {
388		std::mem::take(&mut self.r#accessibility_api)
389	}
390	fn get_accessibility_control(&self) -> &[AccessibilityControlProperty] {
391		self.r#accessibility_control.as_slice()
392	}
393	fn take_accessibility_control(&mut self) -> Vec<AccessibilityControlProperty> {
394		std::mem::take(&mut self.r#accessibility_control)
395	}
396	fn get_accessibility_feature(&self) -> &[AccessibilityFeatureProperty] {
397		self.r#accessibility_feature.as_slice()
398	}
399	fn take_accessibility_feature(&mut self) -> Vec<AccessibilityFeatureProperty> {
400		std::mem::take(&mut self.r#accessibility_feature)
401	}
402	fn get_accessibility_hazard(&self) -> &[AccessibilityHazardProperty] {
403		self.r#accessibility_hazard.as_slice()
404	}
405	fn take_accessibility_hazard(&mut self) -> Vec<AccessibilityHazardProperty> {
406		std::mem::take(&mut self.r#accessibility_hazard)
407	}
408	fn get_accessibility_summary(&self) -> &[AccessibilitySummaryProperty] {
409		self.r#accessibility_summary.as_slice()
410	}
411	fn take_accessibility_summary(&mut self) -> Vec<AccessibilitySummaryProperty> {
412		std::mem::take(&mut self.r#accessibility_summary)
413	}
414	fn get_accountable_person(&self) -> &[AccountablePersonProperty] {
415		self.r#accountable_person.as_slice()
416	}
417	fn take_accountable_person(&mut self) -> Vec<AccountablePersonProperty> {
418		std::mem::take(&mut self.r#accountable_person)
419	}
420	fn get_acquire_license_page(&self) -> &[AcquireLicensePageProperty] {
421		self.r#acquire_license_page.as_slice()
422	}
423	fn take_acquire_license_page(&mut self) -> Vec<AcquireLicensePageProperty> {
424		std::mem::take(&mut self.r#acquire_license_page)
425	}
426	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
427		self.r#aggregate_rating.as_slice()
428	}
429	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
430		std::mem::take(&mut self.r#aggregate_rating)
431	}
432	fn get_alternative_headline(&self) -> &[AlternativeHeadlineProperty] {
433		self.r#alternative_headline.as_slice()
434	}
435	fn take_alternative_headline(&mut self) -> Vec<AlternativeHeadlineProperty> {
436		std::mem::take(&mut self.r#alternative_headline)
437	}
438	fn get_archived_at(&self) -> &[ArchivedAtProperty] {
439		self.r#archived_at.as_slice()
440	}
441	fn take_archived_at(&mut self) -> Vec<ArchivedAtProperty> {
442		std::mem::take(&mut self.r#archived_at)
443	}
444	fn get_assesses(&self) -> &[AssessesProperty] {
445		self.r#assesses.as_slice()
446	}
447	fn take_assesses(&mut self) -> Vec<AssessesProperty> {
448		std::mem::take(&mut self.r#assesses)
449	}
450	fn get_associated_media(&self) -> &[AssociatedMediaProperty] {
451		self.r#associated_media.as_slice()
452	}
453	fn take_associated_media(&mut self) -> Vec<AssociatedMediaProperty> {
454		std::mem::take(&mut self.r#associated_media)
455	}
456	fn get_audience(&self) -> &[AudienceProperty] {
457		self.r#audience.as_slice()
458	}
459	fn take_audience(&mut self) -> Vec<AudienceProperty> {
460		std::mem::take(&mut self.r#audience)
461	}
462	fn get_audio(&self) -> &[AudioProperty] {
463		self.r#audio.as_slice()
464	}
465	fn take_audio(&mut self) -> Vec<AudioProperty> {
466		std::mem::take(&mut self.r#audio)
467	}
468	fn get_author(&self) -> &[AuthorProperty] {
469		self.r#author.as_slice()
470	}
471	fn take_author(&mut self) -> Vec<AuthorProperty> {
472		std::mem::take(&mut self.r#author)
473	}
474	fn get_award(&self) -> &[AwardProperty] {
475		self.r#award.as_slice()
476	}
477	fn take_award(&mut self) -> Vec<AwardProperty> {
478		std::mem::take(&mut self.r#award)
479	}
480	fn get_awards(&self) -> &[AwardsProperty] {
481		self.r#awards.as_slice()
482	}
483	fn take_awards(&mut self) -> Vec<AwardsProperty> {
484		std::mem::take(&mut self.r#awards)
485	}
486	fn get_character(&self) -> &[CharacterProperty] {
487		self.r#character.as_slice()
488	}
489	fn take_character(&mut self) -> Vec<CharacterProperty> {
490		std::mem::take(&mut self.r#character)
491	}
492	fn get_citation(&self) -> &[CitationProperty] {
493		self.r#citation.as_slice()
494	}
495	fn take_citation(&mut self) -> Vec<CitationProperty> {
496		std::mem::take(&mut self.r#citation)
497	}
498	fn get_comment(&self) -> &[CommentProperty] {
499		self.r#comment.as_slice()
500	}
501	fn take_comment(&mut self) -> Vec<CommentProperty> {
502		std::mem::take(&mut self.r#comment)
503	}
504	fn get_comment_count(&self) -> &[CommentCountProperty] {
505		self.r#comment_count.as_slice()
506	}
507	fn take_comment_count(&mut self) -> Vec<CommentCountProperty> {
508		std::mem::take(&mut self.r#comment_count)
509	}
510	fn get_conditions_of_access(&self) -> &[ConditionsOfAccessProperty] {
511		self.r#conditions_of_access.as_slice()
512	}
513	fn take_conditions_of_access(&mut self) -> Vec<ConditionsOfAccessProperty> {
514		std::mem::take(&mut self.r#conditions_of_access)
515	}
516	fn get_content_location(&self) -> &[ContentLocationProperty] {
517		self.r#content_location.as_slice()
518	}
519	fn take_content_location(&mut self) -> Vec<ContentLocationProperty> {
520		std::mem::take(&mut self.r#content_location)
521	}
522	fn get_content_rating(&self) -> &[ContentRatingProperty] {
523		self.r#content_rating.as_slice()
524	}
525	fn take_content_rating(&mut self) -> Vec<ContentRatingProperty> {
526		std::mem::take(&mut self.r#content_rating)
527	}
528	fn get_content_reference_time(&self) -> &[ContentReferenceTimeProperty] {
529		self.r#content_reference_time.as_slice()
530	}
531	fn take_content_reference_time(&mut self) -> Vec<ContentReferenceTimeProperty> {
532		std::mem::take(&mut self.r#content_reference_time)
533	}
534	fn get_contributor(&self) -> &[ContributorProperty] {
535		self.r#contributor.as_slice()
536	}
537	fn take_contributor(&mut self) -> Vec<ContributorProperty> {
538		std::mem::take(&mut self.r#contributor)
539	}
540	fn get_copyright_holder(&self) -> &[CopyrightHolderProperty] {
541		self.r#copyright_holder.as_slice()
542	}
543	fn take_copyright_holder(&mut self) -> Vec<CopyrightHolderProperty> {
544		std::mem::take(&mut self.r#copyright_holder)
545	}
546	fn get_copyright_notice(&self) -> &[CopyrightNoticeProperty] {
547		self.r#copyright_notice.as_slice()
548	}
549	fn take_copyright_notice(&mut self) -> Vec<CopyrightNoticeProperty> {
550		std::mem::take(&mut self.r#copyright_notice)
551	}
552	fn get_copyright_year(&self) -> &[CopyrightYearProperty] {
553		self.r#copyright_year.as_slice()
554	}
555	fn take_copyright_year(&mut self) -> Vec<CopyrightYearProperty> {
556		std::mem::take(&mut self.r#copyright_year)
557	}
558	fn get_correction(&self) -> &[CorrectionProperty] {
559		self.r#correction.as_slice()
560	}
561	fn take_correction(&mut self) -> Vec<CorrectionProperty> {
562		std::mem::take(&mut self.r#correction)
563	}
564	fn get_country_of_origin(&self) -> &[CountryOfOriginProperty] {
565		self.r#country_of_origin.as_slice()
566	}
567	fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty> {
568		std::mem::take(&mut self.r#country_of_origin)
569	}
570	fn get_creative_work_status(&self) -> &[CreativeWorkStatusProperty] {
571		self.r#creative_work_status.as_slice()
572	}
573	fn take_creative_work_status(&mut self) -> Vec<CreativeWorkStatusProperty> {
574		std::mem::take(&mut self.r#creative_work_status)
575	}
576	fn get_creator(&self) -> &[CreatorProperty] {
577		self.r#creator.as_slice()
578	}
579	fn take_creator(&mut self) -> Vec<CreatorProperty> {
580		std::mem::take(&mut self.r#creator)
581	}
582	fn get_credit_text(&self) -> &[CreditTextProperty] {
583		self.r#credit_text.as_slice()
584	}
585	fn take_credit_text(&mut self) -> Vec<CreditTextProperty> {
586		std::mem::take(&mut self.r#credit_text)
587	}
588	fn get_date_created(&self) -> &[DateCreatedProperty] {
589		self.r#date_created.as_slice()
590	}
591	fn take_date_created(&mut self) -> Vec<DateCreatedProperty> {
592		std::mem::take(&mut self.r#date_created)
593	}
594	fn get_date_modified(&self) -> &[DateModifiedProperty] {
595		self.r#date_modified.as_slice()
596	}
597	fn take_date_modified(&mut self) -> Vec<DateModifiedProperty> {
598		std::mem::take(&mut self.r#date_modified)
599	}
600	fn get_date_published(&self) -> &[DatePublishedProperty] {
601		self.r#date_published.as_slice()
602	}
603	fn take_date_published(&mut self) -> Vec<DatePublishedProperty> {
604		std::mem::take(&mut self.r#date_published)
605	}
606	fn get_discussion_url(&self) -> &[DiscussionUrlProperty] {
607		self.r#discussion_url.as_slice()
608	}
609	fn take_discussion_url(&mut self) -> Vec<DiscussionUrlProperty> {
610		std::mem::take(&mut self.r#discussion_url)
611	}
612	fn get_edit_eidr(&self) -> &[EditEidrProperty] {
613		self.r#edit_eidr.as_slice()
614	}
615	fn take_edit_eidr(&mut self) -> Vec<EditEidrProperty> {
616		std::mem::take(&mut self.r#edit_eidr)
617	}
618	fn get_editor(&self) -> &[EditorProperty] {
619		self.r#editor.as_slice()
620	}
621	fn take_editor(&mut self) -> Vec<EditorProperty> {
622		std::mem::take(&mut self.r#editor)
623	}
624	fn get_educational_alignment(&self) -> &[EducationalAlignmentProperty] {
625		self.r#educational_alignment.as_slice()
626	}
627	fn take_educational_alignment(&mut self) -> Vec<EducationalAlignmentProperty> {
628		std::mem::take(&mut self.r#educational_alignment)
629	}
630	fn get_educational_level(&self) -> &[EducationalLevelProperty] {
631		self.r#educational_level.as_slice()
632	}
633	fn take_educational_level(&mut self) -> Vec<EducationalLevelProperty> {
634		std::mem::take(&mut self.r#educational_level)
635	}
636	fn get_educational_use(&self) -> &[EducationalUseProperty] {
637		self.r#educational_use.as_slice()
638	}
639	fn take_educational_use(&mut self) -> Vec<EducationalUseProperty> {
640		std::mem::take(&mut self.r#educational_use)
641	}
642	fn get_encoding(&self) -> &[EncodingProperty] {
643		self.r#encoding.as_slice()
644	}
645	fn take_encoding(&mut self) -> Vec<EncodingProperty> {
646		std::mem::take(&mut self.r#encoding)
647	}
648	fn get_encoding_format(&self) -> &[EncodingFormatProperty] {
649		self.r#encoding_format.as_slice()
650	}
651	fn take_encoding_format(&mut self) -> Vec<EncodingFormatProperty> {
652		std::mem::take(&mut self.r#encoding_format)
653	}
654	fn get_encodings(&self) -> &[EncodingsProperty] {
655		self.r#encodings.as_slice()
656	}
657	fn take_encodings(&mut self) -> Vec<EncodingsProperty> {
658		std::mem::take(&mut self.r#encodings)
659	}
660	fn get_example_of_work(&self) -> &[ExampleOfWorkProperty] {
661		self.r#example_of_work.as_slice()
662	}
663	fn take_example_of_work(&mut self) -> Vec<ExampleOfWorkProperty> {
664		std::mem::take(&mut self.r#example_of_work)
665	}
666	fn get_expires(&self) -> &[ExpiresProperty] {
667		self.r#expires.as_slice()
668	}
669	fn take_expires(&mut self) -> Vec<ExpiresProperty> {
670		std::mem::take(&mut self.r#expires)
671	}
672	fn get_file_format(&self) -> &[FileFormatProperty] {
673		self.r#file_format.as_slice()
674	}
675	fn take_file_format(&mut self) -> Vec<FileFormatProperty> {
676		std::mem::take(&mut self.r#file_format)
677	}
678	fn get_funder(&self) -> &[FunderProperty] {
679		self.r#funder.as_slice()
680	}
681	fn take_funder(&mut self) -> Vec<FunderProperty> {
682		std::mem::take(&mut self.r#funder)
683	}
684	fn get_funding(&self) -> &[FundingProperty] {
685		self.r#funding.as_slice()
686	}
687	fn take_funding(&mut self) -> Vec<FundingProperty> {
688		std::mem::take(&mut self.r#funding)
689	}
690	fn get_genre(&self) -> &[GenreProperty] {
691		self.r#genre.as_slice()
692	}
693	fn take_genre(&mut self) -> Vec<GenreProperty> {
694		std::mem::take(&mut self.r#genre)
695	}
696	fn get_has_part(&self) -> &[HasPartProperty] {
697		self.r#has_part.as_slice()
698	}
699	fn take_has_part(&mut self) -> Vec<HasPartProperty> {
700		std::mem::take(&mut self.r#has_part)
701	}
702	fn get_headline(&self) -> &[HeadlineProperty] {
703		self.r#headline.as_slice()
704	}
705	fn take_headline(&mut self) -> Vec<HeadlineProperty> {
706		std::mem::take(&mut self.r#headline)
707	}
708	fn get_in_language(&self) -> &[InLanguageProperty] {
709		self.r#in_language.as_slice()
710	}
711	fn take_in_language(&mut self) -> Vec<InLanguageProperty> {
712		std::mem::take(&mut self.r#in_language)
713	}
714	fn get_interaction_statistic(&self) -> &[InteractionStatisticProperty] {
715		self.r#interaction_statistic.as_slice()
716	}
717	fn take_interaction_statistic(&mut self) -> Vec<InteractionStatisticProperty> {
718		std::mem::take(&mut self.r#interaction_statistic)
719	}
720	fn get_interactivity_type(&self) -> &[InteractivityTypeProperty] {
721		self.r#interactivity_type.as_slice()
722	}
723	fn take_interactivity_type(&mut self) -> Vec<InteractivityTypeProperty> {
724		std::mem::take(&mut self.r#interactivity_type)
725	}
726	fn get_interpreted_as_claim(&self) -> &[InterpretedAsClaimProperty] {
727		self.r#interpreted_as_claim.as_slice()
728	}
729	fn take_interpreted_as_claim(&mut self) -> Vec<InterpretedAsClaimProperty> {
730		std::mem::take(&mut self.r#interpreted_as_claim)
731	}
732	fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
733		self.r#is_accessible_for_free.as_slice()
734	}
735	fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
736		std::mem::take(&mut self.r#is_accessible_for_free)
737	}
738	fn get_is_based_on(&self) -> &[IsBasedOnProperty] {
739		self.r#is_based_on.as_slice()
740	}
741	fn take_is_based_on(&mut self) -> Vec<IsBasedOnProperty> {
742		std::mem::take(&mut self.r#is_based_on)
743	}
744	fn get_is_based_on_url(&self) -> &[IsBasedOnUrlProperty] {
745		self.r#is_based_on_url.as_slice()
746	}
747	fn take_is_based_on_url(&mut self) -> Vec<IsBasedOnUrlProperty> {
748		std::mem::take(&mut self.r#is_based_on_url)
749	}
750	fn get_is_family_friendly(&self) -> &[IsFamilyFriendlyProperty] {
751		self.r#is_family_friendly.as_slice()
752	}
753	fn take_is_family_friendly(&mut self) -> Vec<IsFamilyFriendlyProperty> {
754		std::mem::take(&mut self.r#is_family_friendly)
755	}
756	fn get_is_part_of(&self) -> &[IsPartOfProperty] {
757		self.r#is_part_of.as_slice()
758	}
759	fn take_is_part_of(&mut self) -> Vec<IsPartOfProperty> {
760		std::mem::take(&mut self.r#is_part_of)
761	}
762	fn get_keywords(&self) -> &[KeywordsProperty] {
763		self.r#keywords.as_slice()
764	}
765	fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
766		std::mem::take(&mut self.r#keywords)
767	}
768	fn get_learning_resource_type(&self) -> &[LearningResourceTypeProperty] {
769		self.r#learning_resource_type.as_slice()
770	}
771	fn take_learning_resource_type(&mut self) -> Vec<LearningResourceTypeProperty> {
772		std::mem::take(&mut self.r#learning_resource_type)
773	}
774	fn get_license(&self) -> &[LicenseProperty] {
775		self.r#license.as_slice()
776	}
777	fn take_license(&mut self) -> Vec<LicenseProperty> {
778		std::mem::take(&mut self.r#license)
779	}
780	fn get_location_created(&self) -> &[LocationCreatedProperty] {
781		self.r#location_created.as_slice()
782	}
783	fn take_location_created(&mut self) -> Vec<LocationCreatedProperty> {
784		std::mem::take(&mut self.r#location_created)
785	}
786	fn get_main_entity(&self) -> &[MainEntityProperty] {
787		self.r#main_entity.as_slice()
788	}
789	fn take_main_entity(&mut self) -> Vec<MainEntityProperty> {
790		std::mem::take(&mut self.r#main_entity)
791	}
792	fn get_maintainer(&self) -> &[MaintainerProperty] {
793		self.r#maintainer.as_slice()
794	}
795	fn take_maintainer(&mut self) -> Vec<MaintainerProperty> {
796		std::mem::take(&mut self.r#maintainer)
797	}
798	fn get_material(&self) -> &[MaterialProperty] {
799		self.r#material.as_slice()
800	}
801	fn take_material(&mut self) -> Vec<MaterialProperty> {
802		std::mem::take(&mut self.r#material)
803	}
804	fn get_material_extent(&self) -> &[MaterialExtentProperty] {
805		self.r#material_extent.as_slice()
806	}
807	fn take_material_extent(&mut self) -> Vec<MaterialExtentProperty> {
808		std::mem::take(&mut self.r#material_extent)
809	}
810	fn get_mentions(&self) -> &[MentionsProperty] {
811		self.r#mentions.as_slice()
812	}
813	fn take_mentions(&mut self) -> Vec<MentionsProperty> {
814		std::mem::take(&mut self.r#mentions)
815	}
816	fn get_offers(&self) -> &[OffersProperty] {
817		self.r#offers.as_slice()
818	}
819	fn take_offers(&mut self) -> Vec<OffersProperty> {
820		std::mem::take(&mut self.r#offers)
821	}
822	fn get_pattern(&self) -> &[PatternProperty] {
823		self.r#pattern.as_slice()
824	}
825	fn take_pattern(&mut self) -> Vec<PatternProperty> {
826		std::mem::take(&mut self.r#pattern)
827	}
828	fn get_position(&self) -> &[PositionProperty] {
829		self.r#position.as_slice()
830	}
831	fn take_position(&mut self) -> Vec<PositionProperty> {
832		std::mem::take(&mut self.r#position)
833	}
834	fn get_producer(&self) -> &[ProducerProperty] {
835		self.r#producer.as_slice()
836	}
837	fn take_producer(&mut self) -> Vec<ProducerProperty> {
838		std::mem::take(&mut self.r#producer)
839	}
840	fn get_provider(&self) -> &[ProviderProperty] {
841		self.r#provider.as_slice()
842	}
843	fn take_provider(&mut self) -> Vec<ProviderProperty> {
844		std::mem::take(&mut self.r#provider)
845	}
846	fn get_publication(&self) -> &[PublicationProperty] {
847		self.r#publication.as_slice()
848	}
849	fn take_publication(&mut self) -> Vec<PublicationProperty> {
850		std::mem::take(&mut self.r#publication)
851	}
852	fn get_publisher(&self) -> &[PublisherProperty] {
853		self.r#publisher.as_slice()
854	}
855	fn take_publisher(&mut self) -> Vec<PublisherProperty> {
856		std::mem::take(&mut self.r#publisher)
857	}
858	fn get_publisher_imprint(&self) -> &[PublisherImprintProperty] {
859		self.r#publisher_imprint.as_slice()
860	}
861	fn take_publisher_imprint(&mut self) -> Vec<PublisherImprintProperty> {
862		std::mem::take(&mut self.r#publisher_imprint)
863	}
864	fn get_publishing_principles(&self) -> &[PublishingPrinciplesProperty] {
865		self.r#publishing_principles.as_slice()
866	}
867	fn take_publishing_principles(&mut self) -> Vec<PublishingPrinciplesProperty> {
868		std::mem::take(&mut self.r#publishing_principles)
869	}
870	fn get_recorded_at(&self) -> &[RecordedAtProperty] {
871		self.r#recorded_at.as_slice()
872	}
873	fn take_recorded_at(&mut self) -> Vec<RecordedAtProperty> {
874		std::mem::take(&mut self.r#recorded_at)
875	}
876	fn get_released_event(&self) -> &[ReleasedEventProperty] {
877		self.r#released_event.as_slice()
878	}
879	fn take_released_event(&mut self) -> Vec<ReleasedEventProperty> {
880		std::mem::take(&mut self.r#released_event)
881	}
882	fn get_review(&self) -> &[ReviewProperty] {
883		self.r#review.as_slice()
884	}
885	fn take_review(&mut self) -> Vec<ReviewProperty> {
886		std::mem::take(&mut self.r#review)
887	}
888	fn get_reviews(&self) -> &[ReviewsProperty] {
889		self.r#reviews.as_slice()
890	}
891	fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
892		std::mem::take(&mut self.r#reviews)
893	}
894	fn get_schema_version(&self) -> &[SchemaVersionProperty] {
895		self.r#schema_version.as_slice()
896	}
897	fn take_schema_version(&mut self) -> Vec<SchemaVersionProperty> {
898		std::mem::take(&mut self.r#schema_version)
899	}
900	fn get_sd_date_published(&self) -> &[SdDatePublishedProperty] {
901		self.r#sd_date_published.as_slice()
902	}
903	fn take_sd_date_published(&mut self) -> Vec<SdDatePublishedProperty> {
904		std::mem::take(&mut self.r#sd_date_published)
905	}
906	fn get_sd_license(&self) -> &[SdLicenseProperty] {
907		self.r#sd_license.as_slice()
908	}
909	fn take_sd_license(&mut self) -> Vec<SdLicenseProperty> {
910		std::mem::take(&mut self.r#sd_license)
911	}
912	fn get_sd_publisher(&self) -> &[SdPublisherProperty] {
913		self.r#sd_publisher.as_slice()
914	}
915	fn take_sd_publisher(&mut self) -> Vec<SdPublisherProperty> {
916		std::mem::take(&mut self.r#sd_publisher)
917	}
918	fn get_size(&self) -> &[SizeProperty] {
919		self.r#size.as_slice()
920	}
921	fn take_size(&mut self) -> Vec<SizeProperty> {
922		std::mem::take(&mut self.r#size)
923	}
924	fn get_source_organization(&self) -> &[SourceOrganizationProperty] {
925		self.r#source_organization.as_slice()
926	}
927	fn take_source_organization(&mut self) -> Vec<SourceOrganizationProperty> {
928		std::mem::take(&mut self.r#source_organization)
929	}
930	fn get_spatial(&self) -> &[SpatialProperty] {
931		self.r#spatial.as_slice()
932	}
933	fn take_spatial(&mut self) -> Vec<SpatialProperty> {
934		std::mem::take(&mut self.r#spatial)
935	}
936	fn get_spatial_coverage(&self) -> &[SpatialCoverageProperty] {
937		self.r#spatial_coverage.as_slice()
938	}
939	fn take_spatial_coverage(&mut self) -> Vec<SpatialCoverageProperty> {
940		std::mem::take(&mut self.r#spatial_coverage)
941	}
942	fn get_sponsor(&self) -> &[SponsorProperty] {
943		self.r#sponsor.as_slice()
944	}
945	fn take_sponsor(&mut self) -> Vec<SponsorProperty> {
946		std::mem::take(&mut self.r#sponsor)
947	}
948	fn get_teaches(&self) -> &[TeachesProperty] {
949		self.r#teaches.as_slice()
950	}
951	fn take_teaches(&mut self) -> Vec<TeachesProperty> {
952		std::mem::take(&mut self.r#teaches)
953	}
954	fn get_temporal(&self) -> &[TemporalProperty] {
955		self.r#temporal.as_slice()
956	}
957	fn take_temporal(&mut self) -> Vec<TemporalProperty> {
958		std::mem::take(&mut self.r#temporal)
959	}
960	fn get_temporal_coverage(&self) -> &[TemporalCoverageProperty] {
961		self.r#temporal_coverage.as_slice()
962	}
963	fn take_temporal_coverage(&mut self) -> Vec<TemporalCoverageProperty> {
964		std::mem::take(&mut self.r#temporal_coverage)
965	}
966	fn get_text(&self) -> &[TextProperty] {
967		self.r#text.as_slice()
968	}
969	fn take_text(&mut self) -> Vec<TextProperty> {
970		std::mem::take(&mut self.r#text)
971	}
972	fn get_thumbnail(&self) -> &[ThumbnailProperty] {
973		self.r#thumbnail.as_slice()
974	}
975	fn take_thumbnail(&mut self) -> Vec<ThumbnailProperty> {
976		std::mem::take(&mut self.r#thumbnail)
977	}
978	fn get_thumbnail_url(&self) -> &[ThumbnailUrlProperty] {
979		self.r#thumbnail_url.as_slice()
980	}
981	fn take_thumbnail_url(&mut self) -> Vec<ThumbnailUrlProperty> {
982		std::mem::take(&mut self.r#thumbnail_url)
983	}
984	fn get_time_required(&self) -> &[TimeRequiredProperty] {
985		self.r#time_required.as_slice()
986	}
987	fn take_time_required(&mut self) -> Vec<TimeRequiredProperty> {
988		std::mem::take(&mut self.r#time_required)
989	}
990	fn get_translation_of_work(&self) -> &[TranslationOfWorkProperty] {
991		self.r#translation_of_work.as_slice()
992	}
993	fn take_translation_of_work(&mut self) -> Vec<TranslationOfWorkProperty> {
994		std::mem::take(&mut self.r#translation_of_work)
995	}
996	fn get_translator(&self) -> &[TranslatorProperty] {
997		self.r#translator.as_slice()
998	}
999	fn take_translator(&mut self) -> Vec<TranslatorProperty> {
1000		std::mem::take(&mut self.r#translator)
1001	}
1002	fn get_typical_age_range(&self) -> &[TypicalAgeRangeProperty] {
1003		self.r#typical_age_range.as_slice()
1004	}
1005	fn take_typical_age_range(&mut self) -> Vec<TypicalAgeRangeProperty> {
1006		std::mem::take(&mut self.r#typical_age_range)
1007	}
1008	fn get_usage_info(&self) -> &[UsageInfoProperty] {
1009		self.r#usage_info.as_slice()
1010	}
1011	fn take_usage_info(&mut self) -> Vec<UsageInfoProperty> {
1012		std::mem::take(&mut self.r#usage_info)
1013	}
1014	fn get_version(&self) -> &[VersionProperty] {
1015		self.r#version.as_slice()
1016	}
1017	fn take_version(&mut self) -> Vec<VersionProperty> {
1018		std::mem::take(&mut self.r#version)
1019	}
1020	fn get_video(&self) -> &[VideoProperty] {
1021		self.r#video.as_slice()
1022	}
1023	fn take_video(&mut self) -> Vec<VideoProperty> {
1024		std::mem::take(&mut self.r#video)
1025	}
1026	fn get_work_example(&self) -> &[WorkExampleProperty] {
1027		self.r#work_example.as_slice()
1028	}
1029	fn take_work_example(&mut self) -> Vec<WorkExampleProperty> {
1030		std::mem::take(&mut self.r#work_example)
1031	}
1032	fn get_work_translation(&self) -> &[WorkTranslationProperty] {
1033		self.r#work_translation.as_slice()
1034	}
1035	fn take_work_translation(&mut self) -> Vec<WorkTranslationProperty> {
1036		std::mem::take(&mut self.r#work_translation)
1037	}
1038}
1039impl CriticReviewTrait for ReviewNewsArticle {}
1040impl NewsArticleTrait for ReviewNewsArticle {
1041	fn get_dateline(&self) -> &[DatelineProperty] {
1042		self.r#dateline.as_slice()
1043	}
1044	fn take_dateline(&mut self) -> Vec<DatelineProperty> {
1045		std::mem::take(&mut self.r#dateline)
1046	}
1047	fn get_print_column(&self) -> &[PrintColumnProperty] {
1048		self.r#print_column.as_slice()
1049	}
1050	fn take_print_column(&mut self) -> Vec<PrintColumnProperty> {
1051		std::mem::take(&mut self.r#print_column)
1052	}
1053	fn get_print_edition(&self) -> &[PrintEditionProperty] {
1054		self.r#print_edition.as_slice()
1055	}
1056	fn take_print_edition(&mut self) -> Vec<PrintEditionProperty> {
1057		std::mem::take(&mut self.r#print_edition)
1058	}
1059	fn get_print_page(&self) -> &[PrintPageProperty] {
1060		self.r#print_page.as_slice()
1061	}
1062	fn take_print_page(&mut self) -> Vec<PrintPageProperty> {
1063		std::mem::take(&mut self.r#print_page)
1064	}
1065	fn get_print_section(&self) -> &[PrintSectionProperty] {
1066		self.r#print_section.as_slice()
1067	}
1068	fn take_print_section(&mut self) -> Vec<PrintSectionProperty> {
1069		std::mem::take(&mut self.r#print_section)
1070	}
1071}
1072impl ReviewTrait for ReviewNewsArticle {
1073	fn get_associated_claim_review(&self) -> &[AssociatedClaimReviewProperty] {
1074		self.r#associated_claim_review.as_slice()
1075	}
1076	fn take_associated_claim_review(&mut self) -> Vec<AssociatedClaimReviewProperty> {
1077		std::mem::take(&mut self.r#associated_claim_review)
1078	}
1079	fn get_associated_media_review(&self) -> &[AssociatedMediaReviewProperty] {
1080		self.r#associated_media_review.as_slice()
1081	}
1082	fn take_associated_media_review(&mut self) -> Vec<AssociatedMediaReviewProperty> {
1083		std::mem::take(&mut self.r#associated_media_review)
1084	}
1085	fn get_associated_review(&self) -> &[AssociatedReviewProperty] {
1086		self.r#associated_review.as_slice()
1087	}
1088	fn take_associated_review(&mut self) -> Vec<AssociatedReviewProperty> {
1089		std::mem::take(&mut self.r#associated_review)
1090	}
1091	fn get_item_reviewed(&self) -> &[ItemReviewedProperty] {
1092		self.r#item_reviewed.as_slice()
1093	}
1094	fn take_item_reviewed(&mut self) -> Vec<ItemReviewedProperty> {
1095		std::mem::take(&mut self.r#item_reviewed)
1096	}
1097	fn get_negative_notes(&self) -> &[NegativeNotesProperty] {
1098		self.r#negative_notes.as_slice()
1099	}
1100	fn take_negative_notes(&mut self) -> Vec<NegativeNotesProperty> {
1101		std::mem::take(&mut self.r#negative_notes)
1102	}
1103	fn get_positive_notes(&self) -> &[PositiveNotesProperty] {
1104		self.r#positive_notes.as_slice()
1105	}
1106	fn take_positive_notes(&mut self) -> Vec<PositiveNotesProperty> {
1107		std::mem::take(&mut self.r#positive_notes)
1108	}
1109	fn get_review_aspect(&self) -> &[ReviewAspectProperty] {
1110		self.r#review_aspect.as_slice()
1111	}
1112	fn take_review_aspect(&mut self) -> Vec<ReviewAspectProperty> {
1113		std::mem::take(&mut self.r#review_aspect)
1114	}
1115	fn get_review_body(&self) -> &[ReviewBodyProperty] {
1116		self.r#review_body.as_slice()
1117	}
1118	fn take_review_body(&mut self) -> Vec<ReviewBodyProperty> {
1119		std::mem::take(&mut self.r#review_body)
1120	}
1121	fn get_review_rating(&self) -> &[ReviewRatingProperty] {
1122		self.r#review_rating.as_slice()
1123	}
1124	fn take_review_rating(&mut self) -> Vec<ReviewRatingProperty> {
1125		std::mem::take(&mut self.r#review_rating)
1126	}
1127}
1128impl ThingTrait for ReviewNewsArticle {
1129	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
1130		self.r#additional_type.as_slice()
1131	}
1132	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
1133		std::mem::take(&mut self.r#additional_type)
1134	}
1135	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
1136		self.r#alternate_name.as_slice()
1137	}
1138	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
1139		std::mem::take(&mut self.r#alternate_name)
1140	}
1141	fn get_description(&self) -> &[DescriptionProperty] {
1142		self.r#description.as_slice()
1143	}
1144	fn take_description(&mut self) -> Vec<DescriptionProperty> {
1145		std::mem::take(&mut self.r#description)
1146	}
1147	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
1148		self.r#disambiguating_description.as_slice()
1149	}
1150	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
1151		std::mem::take(&mut self.r#disambiguating_description)
1152	}
1153	fn get_identifier(&self) -> &[IdentifierProperty] {
1154		self.r#identifier.as_slice()
1155	}
1156	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
1157		std::mem::take(&mut self.r#identifier)
1158	}
1159	fn get_image(&self) -> &[ImageProperty] {
1160		self.r#image.as_slice()
1161	}
1162	fn take_image(&mut self) -> Vec<ImageProperty> {
1163		std::mem::take(&mut self.r#image)
1164	}
1165	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
1166		self.r#main_entity_of_page.as_slice()
1167	}
1168	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
1169		std::mem::take(&mut self.r#main_entity_of_page)
1170	}
1171	fn get_name(&self) -> &[NameProperty] {
1172		self.r#name.as_slice()
1173	}
1174	fn take_name(&mut self) -> Vec<NameProperty> {
1175		std::mem::take(&mut self.r#name)
1176	}
1177	fn get_potential_action(&self) -> &[PotentialActionProperty] {
1178		self.r#potential_action.as_slice()
1179	}
1180	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
1181		std::mem::take(&mut self.r#potential_action)
1182	}
1183	fn get_same_as(&self) -> &[SameAsProperty] {
1184		self.r#same_as.as_slice()
1185	}
1186	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
1187		std::mem::take(&mut self.r#same_as)
1188	}
1189	fn get_subject_of(&self) -> &[SubjectOfProperty] {
1190		self.r#subject_of.as_slice()
1191	}
1192	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
1193		std::mem::take(&mut self.r#subject_of)
1194	}
1195	fn get_url(&self) -> &[UrlProperty] {
1196		self.r#url.as_slice()
1197	}
1198	fn take_url(&mut self) -> Vec<UrlProperty> {
1199		std::mem::take(&mut self.r#url)
1200	}
1201}
1202#[cfg(feature = "serde")]
1203mod serde {
1204	use std::{fmt, fmt::Formatter};
1205
1206	use ::serde::{
1207		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
1208	};
1209
1210	use super::*;
1211	impl Serialize for ReviewNewsArticle {
1212		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1213		where
1214			S: Serializer,
1215		{
1216			let len: usize = [
1217				!Vec::is_empty(&self.r#article_body) as usize,
1218				!Vec::is_empty(&self.r#article_section) as usize,
1219				!Vec::is_empty(&self.r#backstory) as usize,
1220				!Vec::is_empty(&self.r#page_end) as usize,
1221				!Vec::is_empty(&self.r#page_start) as usize,
1222				!Vec::is_empty(&self.r#pagination) as usize,
1223				!Vec::is_empty(&self.r#speakable) as usize,
1224				!Vec::is_empty(&self.r#word_count) as usize,
1225				!Vec::is_empty(&self.r#about) as usize,
1226				!Vec::is_empty(&self.r#abstract) as usize,
1227				!Vec::is_empty(&self.r#access_mode) as usize,
1228				!Vec::is_empty(&self.r#access_mode_sufficient) as usize,
1229				!Vec::is_empty(&self.r#accessibility_api) as usize,
1230				!Vec::is_empty(&self.r#accessibility_control) as usize,
1231				!Vec::is_empty(&self.r#accessibility_feature) as usize,
1232				!Vec::is_empty(&self.r#accessibility_hazard) as usize,
1233				!Vec::is_empty(&self.r#accessibility_summary) as usize,
1234				!Vec::is_empty(&self.r#accountable_person) as usize,
1235				!Vec::is_empty(&self.r#acquire_license_page) as usize,
1236				!Vec::is_empty(&self.r#aggregate_rating) as usize,
1237				!Vec::is_empty(&self.r#alternative_headline) as usize,
1238				!Vec::is_empty(&self.r#archived_at) as usize,
1239				!Vec::is_empty(&self.r#assesses) as usize,
1240				!Vec::is_empty(&self.r#associated_media) as usize,
1241				!Vec::is_empty(&self.r#audience) as usize,
1242				!Vec::is_empty(&self.r#audio) as usize,
1243				!Vec::is_empty(&self.r#author) as usize,
1244				!Vec::is_empty(&self.r#award) as usize,
1245				!Vec::is_empty(&self.r#awards) as usize,
1246				!Vec::is_empty(&self.r#character) as usize,
1247				!Vec::is_empty(&self.r#citation) as usize,
1248				!Vec::is_empty(&self.r#comment) as usize,
1249				!Vec::is_empty(&self.r#comment_count) as usize,
1250				!Vec::is_empty(&self.r#conditions_of_access) as usize,
1251				!Vec::is_empty(&self.r#content_location) as usize,
1252				!Vec::is_empty(&self.r#content_rating) as usize,
1253				!Vec::is_empty(&self.r#content_reference_time) as usize,
1254				!Vec::is_empty(&self.r#contributor) as usize,
1255				!Vec::is_empty(&self.r#copyright_holder) as usize,
1256				!Vec::is_empty(&self.r#copyright_notice) as usize,
1257				!Vec::is_empty(&self.r#copyright_year) as usize,
1258				!Vec::is_empty(&self.r#correction) as usize,
1259				!Vec::is_empty(&self.r#country_of_origin) as usize,
1260				!Vec::is_empty(&self.r#creative_work_status) as usize,
1261				!Vec::is_empty(&self.r#creator) as usize,
1262				!Vec::is_empty(&self.r#credit_text) as usize,
1263				!Vec::is_empty(&self.r#date_created) as usize,
1264				!Vec::is_empty(&self.r#date_modified) as usize,
1265				!Vec::is_empty(&self.r#date_published) as usize,
1266				!Vec::is_empty(&self.r#discussion_url) as usize,
1267				!Vec::is_empty(&self.r#edit_eidr) as usize,
1268				!Vec::is_empty(&self.r#editor) as usize,
1269				!Vec::is_empty(&self.r#educational_alignment) as usize,
1270				!Vec::is_empty(&self.r#educational_level) as usize,
1271				!Vec::is_empty(&self.r#educational_use) as usize,
1272				!Vec::is_empty(&self.r#encoding) as usize,
1273				!Vec::is_empty(&self.r#encoding_format) as usize,
1274				!Vec::is_empty(&self.r#encodings) as usize,
1275				!Vec::is_empty(&self.r#example_of_work) as usize,
1276				!Vec::is_empty(&self.r#expires) as usize,
1277				!Vec::is_empty(&self.r#file_format) as usize,
1278				!Vec::is_empty(&self.r#funder) as usize,
1279				!Vec::is_empty(&self.r#funding) as usize,
1280				!Vec::is_empty(&self.r#genre) as usize,
1281				!Vec::is_empty(&self.r#has_part) as usize,
1282				!Vec::is_empty(&self.r#headline) as usize,
1283				!Vec::is_empty(&self.r#in_language) as usize,
1284				!Vec::is_empty(&self.r#interaction_statistic) as usize,
1285				!Vec::is_empty(&self.r#interactivity_type) as usize,
1286				!Vec::is_empty(&self.r#interpreted_as_claim) as usize,
1287				!Vec::is_empty(&self.r#is_accessible_for_free) as usize,
1288				!Vec::is_empty(&self.r#is_based_on) as usize,
1289				!Vec::is_empty(&self.r#is_based_on_url) as usize,
1290				!Vec::is_empty(&self.r#is_family_friendly) as usize,
1291				!Vec::is_empty(&self.r#is_part_of) as usize,
1292				!Vec::is_empty(&self.r#keywords) as usize,
1293				!Vec::is_empty(&self.r#learning_resource_type) as usize,
1294				!Vec::is_empty(&self.r#license) as usize,
1295				!Vec::is_empty(&self.r#location_created) as usize,
1296				!Vec::is_empty(&self.r#main_entity) as usize,
1297				!Vec::is_empty(&self.r#maintainer) as usize,
1298				!Vec::is_empty(&self.r#material) as usize,
1299				!Vec::is_empty(&self.r#material_extent) as usize,
1300				!Vec::is_empty(&self.r#mentions) as usize,
1301				!Vec::is_empty(&self.r#offers) as usize,
1302				!Vec::is_empty(&self.r#pattern) as usize,
1303				!Vec::is_empty(&self.r#position) as usize,
1304				!Vec::is_empty(&self.r#producer) as usize,
1305				!Vec::is_empty(&self.r#provider) as usize,
1306				!Vec::is_empty(&self.r#publication) as usize,
1307				!Vec::is_empty(&self.r#publisher) as usize,
1308				!Vec::is_empty(&self.r#publisher_imprint) as usize,
1309				!Vec::is_empty(&self.r#publishing_principles) as usize,
1310				!Vec::is_empty(&self.r#recorded_at) as usize,
1311				!Vec::is_empty(&self.r#released_event) as usize,
1312				!Vec::is_empty(&self.r#review) as usize,
1313				!Vec::is_empty(&self.r#reviews) as usize,
1314				!Vec::is_empty(&self.r#schema_version) as usize,
1315				!Vec::is_empty(&self.r#sd_date_published) as usize,
1316				!Vec::is_empty(&self.r#sd_license) as usize,
1317				!Vec::is_empty(&self.r#sd_publisher) as usize,
1318				!Vec::is_empty(&self.r#size) as usize,
1319				!Vec::is_empty(&self.r#source_organization) as usize,
1320				!Vec::is_empty(&self.r#spatial) as usize,
1321				!Vec::is_empty(&self.r#spatial_coverage) as usize,
1322				!Vec::is_empty(&self.r#sponsor) as usize,
1323				!Vec::is_empty(&self.r#teaches) as usize,
1324				!Vec::is_empty(&self.r#temporal) as usize,
1325				!Vec::is_empty(&self.r#temporal_coverage) as usize,
1326				!Vec::is_empty(&self.r#text) as usize,
1327				!Vec::is_empty(&self.r#thumbnail) as usize,
1328				!Vec::is_empty(&self.r#thumbnail_url) as usize,
1329				!Vec::is_empty(&self.r#time_required) as usize,
1330				!Vec::is_empty(&self.r#translation_of_work) as usize,
1331				!Vec::is_empty(&self.r#translator) as usize,
1332				!Vec::is_empty(&self.r#typical_age_range) as usize,
1333				!Vec::is_empty(&self.r#usage_info) as usize,
1334				!Vec::is_empty(&self.r#version) as usize,
1335				!Vec::is_empty(&self.r#video) as usize,
1336				!Vec::is_empty(&self.r#work_example) as usize,
1337				!Vec::is_empty(&self.r#work_translation) as usize,
1338				!Vec::is_empty(&self.r#dateline) as usize,
1339				!Vec::is_empty(&self.r#print_column) as usize,
1340				!Vec::is_empty(&self.r#print_edition) as usize,
1341				!Vec::is_empty(&self.r#print_page) as usize,
1342				!Vec::is_empty(&self.r#print_section) as usize,
1343				!Vec::is_empty(&self.r#associated_claim_review) as usize,
1344				!Vec::is_empty(&self.r#associated_media_review) as usize,
1345				!Vec::is_empty(&self.r#associated_review) as usize,
1346				!Vec::is_empty(&self.r#item_reviewed) as usize,
1347				!Vec::is_empty(&self.r#negative_notes) as usize,
1348				!Vec::is_empty(&self.r#positive_notes) as usize,
1349				!Vec::is_empty(&self.r#review_aspect) as usize,
1350				!Vec::is_empty(&self.r#review_body) as usize,
1351				!Vec::is_empty(&self.r#review_rating) as usize,
1352				!Vec::is_empty(&self.r#additional_type) as usize,
1353				!Vec::is_empty(&self.r#alternate_name) as usize,
1354				!Vec::is_empty(&self.r#description) as usize,
1355				!Vec::is_empty(&self.r#disambiguating_description) as usize,
1356				!Vec::is_empty(&self.r#identifier) as usize,
1357				!Vec::is_empty(&self.r#image) as usize,
1358				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
1359				!Vec::is_empty(&self.r#name) as usize,
1360				!Vec::is_empty(&self.r#potential_action) as usize,
1361				!Vec::is_empty(&self.r#same_as) as usize,
1362				!Vec::is_empty(&self.r#subject_of) as usize,
1363				!Vec::is_empty(&self.r#url) as usize,
1364			]
1365			.iter()
1366			.sum();
1367			let mut serialize_struct =
1368				Serializer::serialize_struct(serializer, "ReviewNewsArticle", len)?;
1369			if !Vec::is_empty(&self.r#article_body) {
1370				serialize_struct.serialize_field("articleBody", {
1371					struct SerializeWith<'a>(&'a Vec<ArticleBodyProperty>);
1372					impl<'a> Serialize for SerializeWith<'a> {
1373						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1374						where
1375							S: Serializer,
1376						{
1377							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1378								self.0, serializer,
1379							)
1380						}
1381					}
1382					&SerializeWith(&self.r#article_body)
1383				})?;
1384			} else {
1385				serialize_struct.skip_field("articleBody")?;
1386			}
1387			if !Vec::is_empty(&self.r#article_section) {
1388				serialize_struct.serialize_field("articleSection", {
1389					struct SerializeWith<'a>(&'a Vec<ArticleSectionProperty>);
1390					impl<'a> Serialize for SerializeWith<'a> {
1391						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1392						where
1393							S: Serializer,
1394						{
1395							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1396								self.0, serializer,
1397							)
1398						}
1399					}
1400					&SerializeWith(&self.r#article_section)
1401				})?;
1402			} else {
1403				serialize_struct.skip_field("articleSection")?;
1404			}
1405			if !Vec::is_empty(&self.r#backstory) {
1406				serialize_struct.serialize_field("backstory", {
1407					struct SerializeWith<'a>(&'a Vec<BackstoryProperty>);
1408					impl<'a> Serialize for SerializeWith<'a> {
1409						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1410						where
1411							S: Serializer,
1412						{
1413							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1414								self.0, serializer,
1415							)
1416						}
1417					}
1418					&SerializeWith(&self.r#backstory)
1419				})?;
1420			} else {
1421				serialize_struct.skip_field("backstory")?;
1422			}
1423			if !Vec::is_empty(&self.r#page_end) {
1424				serialize_struct.serialize_field("pageEnd", {
1425					struct SerializeWith<'a>(&'a Vec<PageEndProperty>);
1426					impl<'a> Serialize for SerializeWith<'a> {
1427						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1428						where
1429							S: Serializer,
1430						{
1431							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1432								self.0, serializer,
1433							)
1434						}
1435					}
1436					&SerializeWith(&self.r#page_end)
1437				})?;
1438			} else {
1439				serialize_struct.skip_field("pageEnd")?;
1440			}
1441			if !Vec::is_empty(&self.r#page_start) {
1442				serialize_struct.serialize_field("pageStart", {
1443					struct SerializeWith<'a>(&'a Vec<PageStartProperty>);
1444					impl<'a> Serialize for SerializeWith<'a> {
1445						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1446						where
1447							S: Serializer,
1448						{
1449							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1450								self.0, serializer,
1451							)
1452						}
1453					}
1454					&SerializeWith(&self.r#page_start)
1455				})?;
1456			} else {
1457				serialize_struct.skip_field("pageStart")?;
1458			}
1459			if !Vec::is_empty(&self.r#pagination) {
1460				serialize_struct.serialize_field("pagination", {
1461					struct SerializeWith<'a>(&'a Vec<PaginationProperty>);
1462					impl<'a> Serialize for SerializeWith<'a> {
1463						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1464						where
1465							S: Serializer,
1466						{
1467							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1468								self.0, serializer,
1469							)
1470						}
1471					}
1472					&SerializeWith(&self.r#pagination)
1473				})?;
1474			} else {
1475				serialize_struct.skip_field("pagination")?;
1476			}
1477			if !Vec::is_empty(&self.r#speakable) {
1478				serialize_struct.serialize_field("speakable", {
1479					struct SerializeWith<'a>(&'a Vec<SpeakableProperty>);
1480					impl<'a> Serialize for SerializeWith<'a> {
1481						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1482						where
1483							S: Serializer,
1484						{
1485							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1486								self.0, serializer,
1487							)
1488						}
1489					}
1490					&SerializeWith(&self.r#speakable)
1491				})?;
1492			} else {
1493				serialize_struct.skip_field("speakable")?;
1494			}
1495			if !Vec::is_empty(&self.r#word_count) {
1496				serialize_struct.serialize_field("wordCount", {
1497					struct SerializeWith<'a>(&'a Vec<WordCountProperty>);
1498					impl<'a> Serialize for SerializeWith<'a> {
1499						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1500						where
1501							S: Serializer,
1502						{
1503							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1504								self.0, serializer,
1505							)
1506						}
1507					}
1508					&SerializeWith(&self.r#word_count)
1509				})?;
1510			} else {
1511				serialize_struct.skip_field("wordCount")?;
1512			}
1513			if !Vec::is_empty(&self.r#about) {
1514				serialize_struct.serialize_field("about", {
1515					struct SerializeWith<'a>(&'a Vec<AboutProperty>);
1516					impl<'a> Serialize for SerializeWith<'a> {
1517						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1518						where
1519							S: Serializer,
1520						{
1521							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1522								self.0, serializer,
1523							)
1524						}
1525					}
1526					&SerializeWith(&self.r#about)
1527				})?;
1528			} else {
1529				serialize_struct.skip_field("about")?;
1530			}
1531			if !Vec::is_empty(&self.r#abstract) {
1532				serialize_struct.serialize_field("abstract", {
1533					struct SerializeWith<'a>(&'a Vec<AbstractProperty>);
1534					impl<'a> Serialize for SerializeWith<'a> {
1535						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1536						where
1537							S: Serializer,
1538						{
1539							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1540								self.0, serializer,
1541							)
1542						}
1543					}
1544					&SerializeWith(&self.r#abstract)
1545				})?;
1546			} else {
1547				serialize_struct.skip_field("abstract")?;
1548			}
1549			if !Vec::is_empty(&self.r#access_mode) {
1550				serialize_struct.serialize_field("accessMode", {
1551					struct SerializeWith<'a>(&'a Vec<AccessModeProperty>);
1552					impl<'a> Serialize for SerializeWith<'a> {
1553						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1554						where
1555							S: Serializer,
1556						{
1557							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1558								self.0, serializer,
1559							)
1560						}
1561					}
1562					&SerializeWith(&self.r#access_mode)
1563				})?;
1564			} else {
1565				serialize_struct.skip_field("accessMode")?;
1566			}
1567			if !Vec::is_empty(&self.r#access_mode_sufficient) {
1568				serialize_struct.serialize_field("accessModeSufficient", {
1569					struct SerializeWith<'a>(&'a Vec<AccessModeSufficientProperty>);
1570					impl<'a> Serialize for SerializeWith<'a> {
1571						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1572						where
1573							S: Serializer,
1574						{
1575							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1576								self.0, serializer,
1577							)
1578						}
1579					}
1580					&SerializeWith(&self.r#access_mode_sufficient)
1581				})?;
1582			} else {
1583				serialize_struct.skip_field("accessModeSufficient")?;
1584			}
1585			if !Vec::is_empty(&self.r#accessibility_api) {
1586				serialize_struct.serialize_field("accessibilityAPI", {
1587					struct SerializeWith<'a>(&'a Vec<AccessibilityApiProperty>);
1588					impl<'a> Serialize for SerializeWith<'a> {
1589						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1590						where
1591							S: Serializer,
1592						{
1593							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1594								self.0, serializer,
1595							)
1596						}
1597					}
1598					&SerializeWith(&self.r#accessibility_api)
1599				})?;
1600			} else {
1601				serialize_struct.skip_field("accessibilityAPI")?;
1602			}
1603			if !Vec::is_empty(&self.r#accessibility_control) {
1604				serialize_struct.serialize_field("accessibilityControl", {
1605					struct SerializeWith<'a>(&'a Vec<AccessibilityControlProperty>);
1606					impl<'a> Serialize for SerializeWith<'a> {
1607						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1608						where
1609							S: Serializer,
1610						{
1611							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1612								self.0, serializer,
1613							)
1614						}
1615					}
1616					&SerializeWith(&self.r#accessibility_control)
1617				})?;
1618			} else {
1619				serialize_struct.skip_field("accessibilityControl")?;
1620			}
1621			if !Vec::is_empty(&self.r#accessibility_feature) {
1622				serialize_struct.serialize_field("accessibilityFeature", {
1623					struct SerializeWith<'a>(&'a Vec<AccessibilityFeatureProperty>);
1624					impl<'a> Serialize for SerializeWith<'a> {
1625						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1626						where
1627							S: Serializer,
1628						{
1629							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1630								self.0, serializer,
1631							)
1632						}
1633					}
1634					&SerializeWith(&self.r#accessibility_feature)
1635				})?;
1636			} else {
1637				serialize_struct.skip_field("accessibilityFeature")?;
1638			}
1639			if !Vec::is_empty(&self.r#accessibility_hazard) {
1640				serialize_struct.serialize_field("accessibilityHazard", {
1641					struct SerializeWith<'a>(&'a Vec<AccessibilityHazardProperty>);
1642					impl<'a> Serialize for SerializeWith<'a> {
1643						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1644						where
1645							S: Serializer,
1646						{
1647							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1648								self.0, serializer,
1649							)
1650						}
1651					}
1652					&SerializeWith(&self.r#accessibility_hazard)
1653				})?;
1654			} else {
1655				serialize_struct.skip_field("accessibilityHazard")?;
1656			}
1657			if !Vec::is_empty(&self.r#accessibility_summary) {
1658				serialize_struct.serialize_field("accessibilitySummary", {
1659					struct SerializeWith<'a>(&'a Vec<AccessibilitySummaryProperty>);
1660					impl<'a> Serialize for SerializeWith<'a> {
1661						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1662						where
1663							S: Serializer,
1664						{
1665							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1666								self.0, serializer,
1667							)
1668						}
1669					}
1670					&SerializeWith(&self.r#accessibility_summary)
1671				})?;
1672			} else {
1673				serialize_struct.skip_field("accessibilitySummary")?;
1674			}
1675			if !Vec::is_empty(&self.r#accountable_person) {
1676				serialize_struct.serialize_field("accountablePerson", {
1677					struct SerializeWith<'a>(&'a Vec<AccountablePersonProperty>);
1678					impl<'a> Serialize for SerializeWith<'a> {
1679						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1680						where
1681							S: Serializer,
1682						{
1683							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1684								self.0, serializer,
1685							)
1686						}
1687					}
1688					&SerializeWith(&self.r#accountable_person)
1689				})?;
1690			} else {
1691				serialize_struct.skip_field("accountablePerson")?;
1692			}
1693			if !Vec::is_empty(&self.r#acquire_license_page) {
1694				serialize_struct.serialize_field("acquireLicensePage", {
1695					struct SerializeWith<'a>(&'a Vec<AcquireLicensePageProperty>);
1696					impl<'a> Serialize for SerializeWith<'a> {
1697						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1698						where
1699							S: Serializer,
1700						{
1701							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1702								self.0, serializer,
1703							)
1704						}
1705					}
1706					&SerializeWith(&self.r#acquire_license_page)
1707				})?;
1708			} else {
1709				serialize_struct.skip_field("acquireLicensePage")?;
1710			}
1711			if !Vec::is_empty(&self.r#aggregate_rating) {
1712				serialize_struct.serialize_field("aggregateRating", {
1713					struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
1714					impl<'a> Serialize for SerializeWith<'a> {
1715						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1716						where
1717							S: Serializer,
1718						{
1719							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1720								self.0, serializer,
1721							)
1722						}
1723					}
1724					&SerializeWith(&self.r#aggregate_rating)
1725				})?;
1726			} else {
1727				serialize_struct.skip_field("aggregateRating")?;
1728			}
1729			if !Vec::is_empty(&self.r#alternative_headline) {
1730				serialize_struct.serialize_field("alternativeHeadline", {
1731					struct SerializeWith<'a>(&'a Vec<AlternativeHeadlineProperty>);
1732					impl<'a> Serialize for SerializeWith<'a> {
1733						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1734						where
1735							S: Serializer,
1736						{
1737							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1738								self.0, serializer,
1739							)
1740						}
1741					}
1742					&SerializeWith(&self.r#alternative_headline)
1743				})?;
1744			} else {
1745				serialize_struct.skip_field("alternativeHeadline")?;
1746			}
1747			if !Vec::is_empty(&self.r#archived_at) {
1748				serialize_struct.serialize_field("archivedAt", {
1749					struct SerializeWith<'a>(&'a Vec<ArchivedAtProperty>);
1750					impl<'a> Serialize for SerializeWith<'a> {
1751						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1752						where
1753							S: Serializer,
1754						{
1755							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1756								self.0, serializer,
1757							)
1758						}
1759					}
1760					&SerializeWith(&self.r#archived_at)
1761				})?;
1762			} else {
1763				serialize_struct.skip_field("archivedAt")?;
1764			}
1765			if !Vec::is_empty(&self.r#assesses) {
1766				serialize_struct.serialize_field("assesses", {
1767					struct SerializeWith<'a>(&'a Vec<AssessesProperty>);
1768					impl<'a> Serialize for SerializeWith<'a> {
1769						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1770						where
1771							S: Serializer,
1772						{
1773							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1774								self.0, serializer,
1775							)
1776						}
1777					}
1778					&SerializeWith(&self.r#assesses)
1779				})?;
1780			} else {
1781				serialize_struct.skip_field("assesses")?;
1782			}
1783			if !Vec::is_empty(&self.r#associated_media) {
1784				serialize_struct.serialize_field("associatedMedia", {
1785					struct SerializeWith<'a>(&'a Vec<AssociatedMediaProperty>);
1786					impl<'a> Serialize for SerializeWith<'a> {
1787						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1788						where
1789							S: Serializer,
1790						{
1791							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1792								self.0, serializer,
1793							)
1794						}
1795					}
1796					&SerializeWith(&self.r#associated_media)
1797				})?;
1798			} else {
1799				serialize_struct.skip_field("associatedMedia")?;
1800			}
1801			if !Vec::is_empty(&self.r#audience) {
1802				serialize_struct.serialize_field("audience", {
1803					struct SerializeWith<'a>(&'a Vec<AudienceProperty>);
1804					impl<'a> Serialize for SerializeWith<'a> {
1805						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1806						where
1807							S: Serializer,
1808						{
1809							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1810								self.0, serializer,
1811							)
1812						}
1813					}
1814					&SerializeWith(&self.r#audience)
1815				})?;
1816			} else {
1817				serialize_struct.skip_field("audience")?;
1818			}
1819			if !Vec::is_empty(&self.r#audio) {
1820				serialize_struct.serialize_field("audio", {
1821					struct SerializeWith<'a>(&'a Vec<AudioProperty>);
1822					impl<'a> Serialize for SerializeWith<'a> {
1823						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1824						where
1825							S: Serializer,
1826						{
1827							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1828								self.0, serializer,
1829							)
1830						}
1831					}
1832					&SerializeWith(&self.r#audio)
1833				})?;
1834			} else {
1835				serialize_struct.skip_field("audio")?;
1836			}
1837			if !Vec::is_empty(&self.r#author) {
1838				serialize_struct.serialize_field("author", {
1839					struct SerializeWith<'a>(&'a Vec<AuthorProperty>);
1840					impl<'a> Serialize for SerializeWith<'a> {
1841						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1842						where
1843							S: Serializer,
1844						{
1845							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1846								self.0, serializer,
1847							)
1848						}
1849					}
1850					&SerializeWith(&self.r#author)
1851				})?;
1852			} else {
1853				serialize_struct.skip_field("author")?;
1854			}
1855			if !Vec::is_empty(&self.r#award) {
1856				serialize_struct.serialize_field("award", {
1857					struct SerializeWith<'a>(&'a Vec<AwardProperty>);
1858					impl<'a> Serialize for SerializeWith<'a> {
1859						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1860						where
1861							S: Serializer,
1862						{
1863							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1864								self.0, serializer,
1865							)
1866						}
1867					}
1868					&SerializeWith(&self.r#award)
1869				})?;
1870			} else {
1871				serialize_struct.skip_field("award")?;
1872			}
1873			if !Vec::is_empty(&self.r#awards) {
1874				serialize_struct.serialize_field("awards", {
1875					struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
1876					impl<'a> Serialize for SerializeWith<'a> {
1877						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1878						where
1879							S: Serializer,
1880						{
1881							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1882								self.0, serializer,
1883							)
1884						}
1885					}
1886					&SerializeWith(&self.r#awards)
1887				})?;
1888			} else {
1889				serialize_struct.skip_field("awards")?;
1890			}
1891			if !Vec::is_empty(&self.r#character) {
1892				serialize_struct.serialize_field("character", {
1893					struct SerializeWith<'a>(&'a Vec<CharacterProperty>);
1894					impl<'a> Serialize for SerializeWith<'a> {
1895						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1896						where
1897							S: Serializer,
1898						{
1899							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1900								self.0, serializer,
1901							)
1902						}
1903					}
1904					&SerializeWith(&self.r#character)
1905				})?;
1906			} else {
1907				serialize_struct.skip_field("character")?;
1908			}
1909			if !Vec::is_empty(&self.r#citation) {
1910				serialize_struct.serialize_field("citation", {
1911					struct SerializeWith<'a>(&'a Vec<CitationProperty>);
1912					impl<'a> Serialize for SerializeWith<'a> {
1913						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1914						where
1915							S: Serializer,
1916						{
1917							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1918								self.0, serializer,
1919							)
1920						}
1921					}
1922					&SerializeWith(&self.r#citation)
1923				})?;
1924			} else {
1925				serialize_struct.skip_field("citation")?;
1926			}
1927			if !Vec::is_empty(&self.r#comment) {
1928				serialize_struct.serialize_field("comment", {
1929					struct SerializeWith<'a>(&'a Vec<CommentProperty>);
1930					impl<'a> Serialize for SerializeWith<'a> {
1931						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1932						where
1933							S: Serializer,
1934						{
1935							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1936								self.0, serializer,
1937							)
1938						}
1939					}
1940					&SerializeWith(&self.r#comment)
1941				})?;
1942			} else {
1943				serialize_struct.skip_field("comment")?;
1944			}
1945			if !Vec::is_empty(&self.r#comment_count) {
1946				serialize_struct.serialize_field("commentCount", {
1947					struct SerializeWith<'a>(&'a Vec<CommentCountProperty>);
1948					impl<'a> Serialize for SerializeWith<'a> {
1949						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1950						where
1951							S: Serializer,
1952						{
1953							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1954								self.0, serializer,
1955							)
1956						}
1957					}
1958					&SerializeWith(&self.r#comment_count)
1959				})?;
1960			} else {
1961				serialize_struct.skip_field("commentCount")?;
1962			}
1963			if !Vec::is_empty(&self.r#conditions_of_access) {
1964				serialize_struct.serialize_field("conditionsOfAccess", {
1965					struct SerializeWith<'a>(&'a Vec<ConditionsOfAccessProperty>);
1966					impl<'a> Serialize for SerializeWith<'a> {
1967						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1968						where
1969							S: Serializer,
1970						{
1971							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1972								self.0, serializer,
1973							)
1974						}
1975					}
1976					&SerializeWith(&self.r#conditions_of_access)
1977				})?;
1978			} else {
1979				serialize_struct.skip_field("conditionsOfAccess")?;
1980			}
1981			if !Vec::is_empty(&self.r#content_location) {
1982				serialize_struct.serialize_field("contentLocation", {
1983					struct SerializeWith<'a>(&'a Vec<ContentLocationProperty>);
1984					impl<'a> Serialize for SerializeWith<'a> {
1985						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1986						where
1987							S: Serializer,
1988						{
1989							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1990								self.0, serializer,
1991							)
1992						}
1993					}
1994					&SerializeWith(&self.r#content_location)
1995				})?;
1996			} else {
1997				serialize_struct.skip_field("contentLocation")?;
1998			}
1999			if !Vec::is_empty(&self.r#content_rating) {
2000				serialize_struct.serialize_field("contentRating", {
2001					struct SerializeWith<'a>(&'a Vec<ContentRatingProperty>);
2002					impl<'a> Serialize for SerializeWith<'a> {
2003						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2004						where
2005							S: Serializer,
2006						{
2007							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2008								self.0, serializer,
2009							)
2010						}
2011					}
2012					&SerializeWith(&self.r#content_rating)
2013				})?;
2014			} else {
2015				serialize_struct.skip_field("contentRating")?;
2016			}
2017			if !Vec::is_empty(&self.r#content_reference_time) {
2018				serialize_struct.serialize_field("contentReferenceTime", {
2019					struct SerializeWith<'a>(&'a Vec<ContentReferenceTimeProperty>);
2020					impl<'a> Serialize for SerializeWith<'a> {
2021						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2022						where
2023							S: Serializer,
2024						{
2025							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2026								self.0, serializer,
2027							)
2028						}
2029					}
2030					&SerializeWith(&self.r#content_reference_time)
2031				})?;
2032			} else {
2033				serialize_struct.skip_field("contentReferenceTime")?;
2034			}
2035			if !Vec::is_empty(&self.r#contributor) {
2036				serialize_struct.serialize_field("contributor", {
2037					struct SerializeWith<'a>(&'a Vec<ContributorProperty>);
2038					impl<'a> Serialize for SerializeWith<'a> {
2039						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2040						where
2041							S: Serializer,
2042						{
2043							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2044								self.0, serializer,
2045							)
2046						}
2047					}
2048					&SerializeWith(&self.r#contributor)
2049				})?;
2050			} else {
2051				serialize_struct.skip_field("contributor")?;
2052			}
2053			if !Vec::is_empty(&self.r#copyright_holder) {
2054				serialize_struct.serialize_field("copyrightHolder", {
2055					struct SerializeWith<'a>(&'a Vec<CopyrightHolderProperty>);
2056					impl<'a> Serialize for SerializeWith<'a> {
2057						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2058						where
2059							S: Serializer,
2060						{
2061							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2062								self.0, serializer,
2063							)
2064						}
2065					}
2066					&SerializeWith(&self.r#copyright_holder)
2067				})?;
2068			} else {
2069				serialize_struct.skip_field("copyrightHolder")?;
2070			}
2071			if !Vec::is_empty(&self.r#copyright_notice) {
2072				serialize_struct.serialize_field("copyrightNotice", {
2073					struct SerializeWith<'a>(&'a Vec<CopyrightNoticeProperty>);
2074					impl<'a> Serialize for SerializeWith<'a> {
2075						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2076						where
2077							S: Serializer,
2078						{
2079							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2080								self.0, serializer,
2081							)
2082						}
2083					}
2084					&SerializeWith(&self.r#copyright_notice)
2085				})?;
2086			} else {
2087				serialize_struct.skip_field("copyrightNotice")?;
2088			}
2089			if !Vec::is_empty(&self.r#copyright_year) {
2090				serialize_struct.serialize_field("copyrightYear", {
2091					struct SerializeWith<'a>(&'a Vec<CopyrightYearProperty>);
2092					impl<'a> Serialize for SerializeWith<'a> {
2093						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2094						where
2095							S: Serializer,
2096						{
2097							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2098								self.0, serializer,
2099							)
2100						}
2101					}
2102					&SerializeWith(&self.r#copyright_year)
2103				})?;
2104			} else {
2105				serialize_struct.skip_field("copyrightYear")?;
2106			}
2107			if !Vec::is_empty(&self.r#correction) {
2108				serialize_struct.serialize_field("correction", {
2109					struct SerializeWith<'a>(&'a Vec<CorrectionProperty>);
2110					impl<'a> Serialize for SerializeWith<'a> {
2111						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2112						where
2113							S: Serializer,
2114						{
2115							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2116								self.0, serializer,
2117							)
2118						}
2119					}
2120					&SerializeWith(&self.r#correction)
2121				})?;
2122			} else {
2123				serialize_struct.skip_field("correction")?;
2124			}
2125			if !Vec::is_empty(&self.r#country_of_origin) {
2126				serialize_struct.serialize_field("countryOfOrigin", {
2127					struct SerializeWith<'a>(&'a Vec<CountryOfOriginProperty>);
2128					impl<'a> Serialize for SerializeWith<'a> {
2129						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2130						where
2131							S: Serializer,
2132						{
2133							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2134								self.0, serializer,
2135							)
2136						}
2137					}
2138					&SerializeWith(&self.r#country_of_origin)
2139				})?;
2140			} else {
2141				serialize_struct.skip_field("countryOfOrigin")?;
2142			}
2143			if !Vec::is_empty(&self.r#creative_work_status) {
2144				serialize_struct.serialize_field("creativeWorkStatus", {
2145					struct SerializeWith<'a>(&'a Vec<CreativeWorkStatusProperty>);
2146					impl<'a> Serialize for SerializeWith<'a> {
2147						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2148						where
2149							S: Serializer,
2150						{
2151							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2152								self.0, serializer,
2153							)
2154						}
2155					}
2156					&SerializeWith(&self.r#creative_work_status)
2157				})?;
2158			} else {
2159				serialize_struct.skip_field("creativeWorkStatus")?;
2160			}
2161			if !Vec::is_empty(&self.r#creator) {
2162				serialize_struct.serialize_field("creator", {
2163					struct SerializeWith<'a>(&'a Vec<CreatorProperty>);
2164					impl<'a> Serialize for SerializeWith<'a> {
2165						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2166						where
2167							S: Serializer,
2168						{
2169							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2170								self.0, serializer,
2171							)
2172						}
2173					}
2174					&SerializeWith(&self.r#creator)
2175				})?;
2176			} else {
2177				serialize_struct.skip_field("creator")?;
2178			}
2179			if !Vec::is_empty(&self.r#credit_text) {
2180				serialize_struct.serialize_field("creditText", {
2181					struct SerializeWith<'a>(&'a Vec<CreditTextProperty>);
2182					impl<'a> Serialize for SerializeWith<'a> {
2183						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2184						where
2185							S: Serializer,
2186						{
2187							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2188								self.0, serializer,
2189							)
2190						}
2191					}
2192					&SerializeWith(&self.r#credit_text)
2193				})?;
2194			} else {
2195				serialize_struct.skip_field("creditText")?;
2196			}
2197			if !Vec::is_empty(&self.r#date_created) {
2198				serialize_struct.serialize_field("dateCreated", {
2199					struct SerializeWith<'a>(&'a Vec<DateCreatedProperty>);
2200					impl<'a> Serialize for SerializeWith<'a> {
2201						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2202						where
2203							S: Serializer,
2204						{
2205							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2206								self.0, serializer,
2207							)
2208						}
2209					}
2210					&SerializeWith(&self.r#date_created)
2211				})?;
2212			} else {
2213				serialize_struct.skip_field("dateCreated")?;
2214			}
2215			if !Vec::is_empty(&self.r#date_modified) {
2216				serialize_struct.serialize_field("dateModified", {
2217					struct SerializeWith<'a>(&'a Vec<DateModifiedProperty>);
2218					impl<'a> Serialize for SerializeWith<'a> {
2219						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2220						where
2221							S: Serializer,
2222						{
2223							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2224								self.0, serializer,
2225							)
2226						}
2227					}
2228					&SerializeWith(&self.r#date_modified)
2229				})?;
2230			} else {
2231				serialize_struct.skip_field("dateModified")?;
2232			}
2233			if !Vec::is_empty(&self.r#date_published) {
2234				serialize_struct.serialize_field("datePublished", {
2235					struct SerializeWith<'a>(&'a Vec<DatePublishedProperty>);
2236					impl<'a> Serialize for SerializeWith<'a> {
2237						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2238						where
2239							S: Serializer,
2240						{
2241							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2242								self.0, serializer,
2243							)
2244						}
2245					}
2246					&SerializeWith(&self.r#date_published)
2247				})?;
2248			} else {
2249				serialize_struct.skip_field("datePublished")?;
2250			}
2251			if !Vec::is_empty(&self.r#discussion_url) {
2252				serialize_struct.serialize_field("discussionUrl", {
2253					struct SerializeWith<'a>(&'a Vec<DiscussionUrlProperty>);
2254					impl<'a> Serialize for SerializeWith<'a> {
2255						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2256						where
2257							S: Serializer,
2258						{
2259							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2260								self.0, serializer,
2261							)
2262						}
2263					}
2264					&SerializeWith(&self.r#discussion_url)
2265				})?;
2266			} else {
2267				serialize_struct.skip_field("discussionUrl")?;
2268			}
2269			if !Vec::is_empty(&self.r#edit_eidr) {
2270				serialize_struct.serialize_field("editEIDR", {
2271					struct SerializeWith<'a>(&'a Vec<EditEidrProperty>);
2272					impl<'a> Serialize for SerializeWith<'a> {
2273						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2274						where
2275							S: Serializer,
2276						{
2277							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2278								self.0, serializer,
2279							)
2280						}
2281					}
2282					&SerializeWith(&self.r#edit_eidr)
2283				})?;
2284			} else {
2285				serialize_struct.skip_field("editEIDR")?;
2286			}
2287			if !Vec::is_empty(&self.r#editor) {
2288				serialize_struct.serialize_field("editor", {
2289					struct SerializeWith<'a>(&'a Vec<EditorProperty>);
2290					impl<'a> Serialize for SerializeWith<'a> {
2291						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2292						where
2293							S: Serializer,
2294						{
2295							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2296								self.0, serializer,
2297							)
2298						}
2299					}
2300					&SerializeWith(&self.r#editor)
2301				})?;
2302			} else {
2303				serialize_struct.skip_field("editor")?;
2304			}
2305			if !Vec::is_empty(&self.r#educational_alignment) {
2306				serialize_struct.serialize_field("educationalAlignment", {
2307					struct SerializeWith<'a>(&'a Vec<EducationalAlignmentProperty>);
2308					impl<'a> Serialize for SerializeWith<'a> {
2309						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2310						where
2311							S: Serializer,
2312						{
2313							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2314								self.0, serializer,
2315							)
2316						}
2317					}
2318					&SerializeWith(&self.r#educational_alignment)
2319				})?;
2320			} else {
2321				serialize_struct.skip_field("educationalAlignment")?;
2322			}
2323			if !Vec::is_empty(&self.r#educational_level) {
2324				serialize_struct.serialize_field("educationalLevel", {
2325					struct SerializeWith<'a>(&'a Vec<EducationalLevelProperty>);
2326					impl<'a> Serialize for SerializeWith<'a> {
2327						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2328						where
2329							S: Serializer,
2330						{
2331							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2332								self.0, serializer,
2333							)
2334						}
2335					}
2336					&SerializeWith(&self.r#educational_level)
2337				})?;
2338			} else {
2339				serialize_struct.skip_field("educationalLevel")?;
2340			}
2341			if !Vec::is_empty(&self.r#educational_use) {
2342				serialize_struct.serialize_field("educationalUse", {
2343					struct SerializeWith<'a>(&'a Vec<EducationalUseProperty>);
2344					impl<'a> Serialize for SerializeWith<'a> {
2345						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2346						where
2347							S: Serializer,
2348						{
2349							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2350								self.0, serializer,
2351							)
2352						}
2353					}
2354					&SerializeWith(&self.r#educational_use)
2355				})?;
2356			} else {
2357				serialize_struct.skip_field("educationalUse")?;
2358			}
2359			if !Vec::is_empty(&self.r#encoding) {
2360				serialize_struct.serialize_field("encoding", {
2361					struct SerializeWith<'a>(&'a Vec<EncodingProperty>);
2362					impl<'a> Serialize for SerializeWith<'a> {
2363						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2364						where
2365							S: Serializer,
2366						{
2367							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2368								self.0, serializer,
2369							)
2370						}
2371					}
2372					&SerializeWith(&self.r#encoding)
2373				})?;
2374			} else {
2375				serialize_struct.skip_field("encoding")?;
2376			}
2377			if !Vec::is_empty(&self.r#encoding_format) {
2378				serialize_struct.serialize_field("encodingFormat", {
2379					struct SerializeWith<'a>(&'a Vec<EncodingFormatProperty>);
2380					impl<'a> Serialize for SerializeWith<'a> {
2381						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2382						where
2383							S: Serializer,
2384						{
2385							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2386								self.0, serializer,
2387							)
2388						}
2389					}
2390					&SerializeWith(&self.r#encoding_format)
2391				})?;
2392			} else {
2393				serialize_struct.skip_field("encodingFormat")?;
2394			}
2395			if !Vec::is_empty(&self.r#encodings) {
2396				serialize_struct.serialize_field("encodings", {
2397					struct SerializeWith<'a>(&'a Vec<EncodingsProperty>);
2398					impl<'a> Serialize for SerializeWith<'a> {
2399						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2400						where
2401							S: Serializer,
2402						{
2403							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2404								self.0, serializer,
2405							)
2406						}
2407					}
2408					&SerializeWith(&self.r#encodings)
2409				})?;
2410			} else {
2411				serialize_struct.skip_field("encodings")?;
2412			}
2413			if !Vec::is_empty(&self.r#example_of_work) {
2414				serialize_struct.serialize_field("exampleOfWork", {
2415					struct SerializeWith<'a>(&'a Vec<ExampleOfWorkProperty>);
2416					impl<'a> Serialize for SerializeWith<'a> {
2417						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2418						where
2419							S: Serializer,
2420						{
2421							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2422								self.0, serializer,
2423							)
2424						}
2425					}
2426					&SerializeWith(&self.r#example_of_work)
2427				})?;
2428			} else {
2429				serialize_struct.skip_field("exampleOfWork")?;
2430			}
2431			if !Vec::is_empty(&self.r#expires) {
2432				serialize_struct.serialize_field("expires", {
2433					struct SerializeWith<'a>(&'a Vec<ExpiresProperty>);
2434					impl<'a> Serialize for SerializeWith<'a> {
2435						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2436						where
2437							S: Serializer,
2438						{
2439							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2440								self.0, serializer,
2441							)
2442						}
2443					}
2444					&SerializeWith(&self.r#expires)
2445				})?;
2446			} else {
2447				serialize_struct.skip_field("expires")?;
2448			}
2449			if !Vec::is_empty(&self.r#file_format) {
2450				serialize_struct.serialize_field("fileFormat", {
2451					struct SerializeWith<'a>(&'a Vec<FileFormatProperty>);
2452					impl<'a> Serialize for SerializeWith<'a> {
2453						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2454						where
2455							S: Serializer,
2456						{
2457							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2458								self.0, serializer,
2459							)
2460						}
2461					}
2462					&SerializeWith(&self.r#file_format)
2463				})?;
2464			} else {
2465				serialize_struct.skip_field("fileFormat")?;
2466			}
2467			if !Vec::is_empty(&self.r#funder) {
2468				serialize_struct.serialize_field("funder", {
2469					struct SerializeWith<'a>(&'a Vec<FunderProperty>);
2470					impl<'a> Serialize for SerializeWith<'a> {
2471						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2472						where
2473							S: Serializer,
2474						{
2475							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2476								self.0, serializer,
2477							)
2478						}
2479					}
2480					&SerializeWith(&self.r#funder)
2481				})?;
2482			} else {
2483				serialize_struct.skip_field("funder")?;
2484			}
2485			if !Vec::is_empty(&self.r#funding) {
2486				serialize_struct.serialize_field("funding", {
2487					struct SerializeWith<'a>(&'a Vec<FundingProperty>);
2488					impl<'a> Serialize for SerializeWith<'a> {
2489						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2490						where
2491							S: Serializer,
2492						{
2493							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2494								self.0, serializer,
2495							)
2496						}
2497					}
2498					&SerializeWith(&self.r#funding)
2499				})?;
2500			} else {
2501				serialize_struct.skip_field("funding")?;
2502			}
2503			if !Vec::is_empty(&self.r#genre) {
2504				serialize_struct.serialize_field("genre", {
2505					struct SerializeWith<'a>(&'a Vec<GenreProperty>);
2506					impl<'a> Serialize for SerializeWith<'a> {
2507						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2508						where
2509							S: Serializer,
2510						{
2511							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2512								self.0, serializer,
2513							)
2514						}
2515					}
2516					&SerializeWith(&self.r#genre)
2517				})?;
2518			} else {
2519				serialize_struct.skip_field("genre")?;
2520			}
2521			if !Vec::is_empty(&self.r#has_part) {
2522				serialize_struct.serialize_field("hasPart", {
2523					struct SerializeWith<'a>(&'a Vec<HasPartProperty>);
2524					impl<'a> Serialize for SerializeWith<'a> {
2525						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2526						where
2527							S: Serializer,
2528						{
2529							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2530								self.0, serializer,
2531							)
2532						}
2533					}
2534					&SerializeWith(&self.r#has_part)
2535				})?;
2536			} else {
2537				serialize_struct.skip_field("hasPart")?;
2538			}
2539			if !Vec::is_empty(&self.r#headline) {
2540				serialize_struct.serialize_field("headline", {
2541					struct SerializeWith<'a>(&'a Vec<HeadlineProperty>);
2542					impl<'a> Serialize for SerializeWith<'a> {
2543						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2544						where
2545							S: Serializer,
2546						{
2547							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2548								self.0, serializer,
2549							)
2550						}
2551					}
2552					&SerializeWith(&self.r#headline)
2553				})?;
2554			} else {
2555				serialize_struct.skip_field("headline")?;
2556			}
2557			if !Vec::is_empty(&self.r#in_language) {
2558				serialize_struct.serialize_field("inLanguage", {
2559					struct SerializeWith<'a>(&'a Vec<InLanguageProperty>);
2560					impl<'a> Serialize for SerializeWith<'a> {
2561						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2562						where
2563							S: Serializer,
2564						{
2565							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2566								self.0, serializer,
2567							)
2568						}
2569					}
2570					&SerializeWith(&self.r#in_language)
2571				})?;
2572			} else {
2573				serialize_struct.skip_field("inLanguage")?;
2574			}
2575			if !Vec::is_empty(&self.r#interaction_statistic) {
2576				serialize_struct.serialize_field("interactionStatistic", {
2577					struct SerializeWith<'a>(&'a Vec<InteractionStatisticProperty>);
2578					impl<'a> Serialize for SerializeWith<'a> {
2579						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2580						where
2581							S: Serializer,
2582						{
2583							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2584								self.0, serializer,
2585							)
2586						}
2587					}
2588					&SerializeWith(&self.r#interaction_statistic)
2589				})?;
2590			} else {
2591				serialize_struct.skip_field("interactionStatistic")?;
2592			}
2593			if !Vec::is_empty(&self.r#interactivity_type) {
2594				serialize_struct.serialize_field("interactivityType", {
2595					struct SerializeWith<'a>(&'a Vec<InteractivityTypeProperty>);
2596					impl<'a> Serialize for SerializeWith<'a> {
2597						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2598						where
2599							S: Serializer,
2600						{
2601							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2602								self.0, serializer,
2603							)
2604						}
2605					}
2606					&SerializeWith(&self.r#interactivity_type)
2607				})?;
2608			} else {
2609				serialize_struct.skip_field("interactivityType")?;
2610			}
2611			if !Vec::is_empty(&self.r#interpreted_as_claim) {
2612				serialize_struct.serialize_field("interpretedAsClaim", {
2613					struct SerializeWith<'a>(&'a Vec<InterpretedAsClaimProperty>);
2614					impl<'a> Serialize for SerializeWith<'a> {
2615						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2616						where
2617							S: Serializer,
2618						{
2619							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2620								self.0, serializer,
2621							)
2622						}
2623					}
2624					&SerializeWith(&self.r#interpreted_as_claim)
2625				})?;
2626			} else {
2627				serialize_struct.skip_field("interpretedAsClaim")?;
2628			}
2629			if !Vec::is_empty(&self.r#is_accessible_for_free) {
2630				serialize_struct.serialize_field("isAccessibleForFree", {
2631					struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
2632					impl<'a> Serialize for SerializeWith<'a> {
2633						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2634						where
2635							S: Serializer,
2636						{
2637							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2638								self.0, serializer,
2639							)
2640						}
2641					}
2642					&SerializeWith(&self.r#is_accessible_for_free)
2643				})?;
2644			} else {
2645				serialize_struct.skip_field("isAccessibleForFree")?;
2646			}
2647			if !Vec::is_empty(&self.r#is_based_on) {
2648				serialize_struct.serialize_field("isBasedOn", {
2649					struct SerializeWith<'a>(&'a Vec<IsBasedOnProperty>);
2650					impl<'a> Serialize for SerializeWith<'a> {
2651						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2652						where
2653							S: Serializer,
2654						{
2655							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2656								self.0, serializer,
2657							)
2658						}
2659					}
2660					&SerializeWith(&self.r#is_based_on)
2661				})?;
2662			} else {
2663				serialize_struct.skip_field("isBasedOn")?;
2664			}
2665			if !Vec::is_empty(&self.r#is_based_on_url) {
2666				serialize_struct.serialize_field("isBasedOnUrl", {
2667					struct SerializeWith<'a>(&'a Vec<IsBasedOnUrlProperty>);
2668					impl<'a> Serialize for SerializeWith<'a> {
2669						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2670						where
2671							S: Serializer,
2672						{
2673							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2674								self.0, serializer,
2675							)
2676						}
2677					}
2678					&SerializeWith(&self.r#is_based_on_url)
2679				})?;
2680			} else {
2681				serialize_struct.skip_field("isBasedOnUrl")?;
2682			}
2683			if !Vec::is_empty(&self.r#is_family_friendly) {
2684				serialize_struct.serialize_field("isFamilyFriendly", {
2685					struct SerializeWith<'a>(&'a Vec<IsFamilyFriendlyProperty>);
2686					impl<'a> Serialize for SerializeWith<'a> {
2687						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2688						where
2689							S: Serializer,
2690						{
2691							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2692								self.0, serializer,
2693							)
2694						}
2695					}
2696					&SerializeWith(&self.r#is_family_friendly)
2697				})?;
2698			} else {
2699				serialize_struct.skip_field("isFamilyFriendly")?;
2700			}
2701			if !Vec::is_empty(&self.r#is_part_of) {
2702				serialize_struct.serialize_field("isPartOf", {
2703					struct SerializeWith<'a>(&'a Vec<IsPartOfProperty>);
2704					impl<'a> Serialize for SerializeWith<'a> {
2705						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2706						where
2707							S: Serializer,
2708						{
2709							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2710								self.0, serializer,
2711							)
2712						}
2713					}
2714					&SerializeWith(&self.r#is_part_of)
2715				})?;
2716			} else {
2717				serialize_struct.skip_field("isPartOf")?;
2718			}
2719			if !Vec::is_empty(&self.r#keywords) {
2720				serialize_struct.serialize_field("keywords", {
2721					struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
2722					impl<'a> Serialize for SerializeWith<'a> {
2723						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2724						where
2725							S: Serializer,
2726						{
2727							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2728								self.0, serializer,
2729							)
2730						}
2731					}
2732					&SerializeWith(&self.r#keywords)
2733				})?;
2734			} else {
2735				serialize_struct.skip_field("keywords")?;
2736			}
2737			if !Vec::is_empty(&self.r#learning_resource_type) {
2738				serialize_struct.serialize_field("learningResourceType", {
2739					struct SerializeWith<'a>(&'a Vec<LearningResourceTypeProperty>);
2740					impl<'a> Serialize for SerializeWith<'a> {
2741						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2742						where
2743							S: Serializer,
2744						{
2745							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2746								self.0, serializer,
2747							)
2748						}
2749					}
2750					&SerializeWith(&self.r#learning_resource_type)
2751				})?;
2752			} else {
2753				serialize_struct.skip_field("learningResourceType")?;
2754			}
2755			if !Vec::is_empty(&self.r#license) {
2756				serialize_struct.serialize_field("license", {
2757					struct SerializeWith<'a>(&'a Vec<LicenseProperty>);
2758					impl<'a> Serialize for SerializeWith<'a> {
2759						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2760						where
2761							S: Serializer,
2762						{
2763							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2764								self.0, serializer,
2765							)
2766						}
2767					}
2768					&SerializeWith(&self.r#license)
2769				})?;
2770			} else {
2771				serialize_struct.skip_field("license")?;
2772			}
2773			if !Vec::is_empty(&self.r#location_created) {
2774				serialize_struct.serialize_field("locationCreated", {
2775					struct SerializeWith<'a>(&'a Vec<LocationCreatedProperty>);
2776					impl<'a> Serialize for SerializeWith<'a> {
2777						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2778						where
2779							S: Serializer,
2780						{
2781							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2782								self.0, serializer,
2783							)
2784						}
2785					}
2786					&SerializeWith(&self.r#location_created)
2787				})?;
2788			} else {
2789				serialize_struct.skip_field("locationCreated")?;
2790			}
2791			if !Vec::is_empty(&self.r#main_entity) {
2792				serialize_struct.serialize_field("mainEntity", {
2793					struct SerializeWith<'a>(&'a Vec<MainEntityProperty>);
2794					impl<'a> Serialize for SerializeWith<'a> {
2795						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2796						where
2797							S: Serializer,
2798						{
2799							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2800								self.0, serializer,
2801							)
2802						}
2803					}
2804					&SerializeWith(&self.r#main_entity)
2805				})?;
2806			} else {
2807				serialize_struct.skip_field("mainEntity")?;
2808			}
2809			if !Vec::is_empty(&self.r#maintainer) {
2810				serialize_struct.serialize_field("maintainer", {
2811					struct SerializeWith<'a>(&'a Vec<MaintainerProperty>);
2812					impl<'a> Serialize for SerializeWith<'a> {
2813						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2814						where
2815							S: Serializer,
2816						{
2817							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2818								self.0, serializer,
2819							)
2820						}
2821					}
2822					&SerializeWith(&self.r#maintainer)
2823				})?;
2824			} else {
2825				serialize_struct.skip_field("maintainer")?;
2826			}
2827			if !Vec::is_empty(&self.r#material) {
2828				serialize_struct.serialize_field("material", {
2829					struct SerializeWith<'a>(&'a Vec<MaterialProperty>);
2830					impl<'a> Serialize for SerializeWith<'a> {
2831						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2832						where
2833							S: Serializer,
2834						{
2835							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2836								self.0, serializer,
2837							)
2838						}
2839					}
2840					&SerializeWith(&self.r#material)
2841				})?;
2842			} else {
2843				serialize_struct.skip_field("material")?;
2844			}
2845			if !Vec::is_empty(&self.r#material_extent) {
2846				serialize_struct.serialize_field("materialExtent", {
2847					struct SerializeWith<'a>(&'a Vec<MaterialExtentProperty>);
2848					impl<'a> Serialize for SerializeWith<'a> {
2849						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2850						where
2851							S: Serializer,
2852						{
2853							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2854								self.0, serializer,
2855							)
2856						}
2857					}
2858					&SerializeWith(&self.r#material_extent)
2859				})?;
2860			} else {
2861				serialize_struct.skip_field("materialExtent")?;
2862			}
2863			if !Vec::is_empty(&self.r#mentions) {
2864				serialize_struct.serialize_field("mentions", {
2865					struct SerializeWith<'a>(&'a Vec<MentionsProperty>);
2866					impl<'a> Serialize for SerializeWith<'a> {
2867						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2868						where
2869							S: Serializer,
2870						{
2871							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2872								self.0, serializer,
2873							)
2874						}
2875					}
2876					&SerializeWith(&self.r#mentions)
2877				})?;
2878			} else {
2879				serialize_struct.skip_field("mentions")?;
2880			}
2881			if !Vec::is_empty(&self.r#offers) {
2882				serialize_struct.serialize_field("offers", {
2883					struct SerializeWith<'a>(&'a Vec<OffersProperty>);
2884					impl<'a> Serialize for SerializeWith<'a> {
2885						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2886						where
2887							S: Serializer,
2888						{
2889							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2890								self.0, serializer,
2891							)
2892						}
2893					}
2894					&SerializeWith(&self.r#offers)
2895				})?;
2896			} else {
2897				serialize_struct.skip_field("offers")?;
2898			}
2899			if !Vec::is_empty(&self.r#pattern) {
2900				serialize_struct.serialize_field("pattern", {
2901					struct SerializeWith<'a>(&'a Vec<PatternProperty>);
2902					impl<'a> Serialize for SerializeWith<'a> {
2903						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2904						where
2905							S: Serializer,
2906						{
2907							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2908								self.0, serializer,
2909							)
2910						}
2911					}
2912					&SerializeWith(&self.r#pattern)
2913				})?;
2914			} else {
2915				serialize_struct.skip_field("pattern")?;
2916			}
2917			if !Vec::is_empty(&self.r#position) {
2918				serialize_struct.serialize_field("position", {
2919					struct SerializeWith<'a>(&'a Vec<PositionProperty>);
2920					impl<'a> Serialize for SerializeWith<'a> {
2921						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2922						where
2923							S: Serializer,
2924						{
2925							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2926								self.0, serializer,
2927							)
2928						}
2929					}
2930					&SerializeWith(&self.r#position)
2931				})?;
2932			} else {
2933				serialize_struct.skip_field("position")?;
2934			}
2935			if !Vec::is_empty(&self.r#producer) {
2936				serialize_struct.serialize_field("producer", {
2937					struct SerializeWith<'a>(&'a Vec<ProducerProperty>);
2938					impl<'a> Serialize for SerializeWith<'a> {
2939						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2940						where
2941							S: Serializer,
2942						{
2943							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2944								self.0, serializer,
2945							)
2946						}
2947					}
2948					&SerializeWith(&self.r#producer)
2949				})?;
2950			} else {
2951				serialize_struct.skip_field("producer")?;
2952			}
2953			if !Vec::is_empty(&self.r#provider) {
2954				serialize_struct.serialize_field("provider", {
2955					struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
2956					impl<'a> Serialize for SerializeWith<'a> {
2957						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2958						where
2959							S: Serializer,
2960						{
2961							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2962								self.0, serializer,
2963							)
2964						}
2965					}
2966					&SerializeWith(&self.r#provider)
2967				})?;
2968			} else {
2969				serialize_struct.skip_field("provider")?;
2970			}
2971			if !Vec::is_empty(&self.r#publication) {
2972				serialize_struct.serialize_field("publication", {
2973					struct SerializeWith<'a>(&'a Vec<PublicationProperty>);
2974					impl<'a> Serialize for SerializeWith<'a> {
2975						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2976						where
2977							S: Serializer,
2978						{
2979							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2980								self.0, serializer,
2981							)
2982						}
2983					}
2984					&SerializeWith(&self.r#publication)
2985				})?;
2986			} else {
2987				serialize_struct.skip_field("publication")?;
2988			}
2989			if !Vec::is_empty(&self.r#publisher) {
2990				serialize_struct.serialize_field("publisher", {
2991					struct SerializeWith<'a>(&'a Vec<PublisherProperty>);
2992					impl<'a> Serialize for SerializeWith<'a> {
2993						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2994						where
2995							S: Serializer,
2996						{
2997							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2998								self.0, serializer,
2999							)
3000						}
3001					}
3002					&SerializeWith(&self.r#publisher)
3003				})?;
3004			} else {
3005				serialize_struct.skip_field("publisher")?;
3006			}
3007			if !Vec::is_empty(&self.r#publisher_imprint) {
3008				serialize_struct.serialize_field("publisherImprint", {
3009					struct SerializeWith<'a>(&'a Vec<PublisherImprintProperty>);
3010					impl<'a> Serialize for SerializeWith<'a> {
3011						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3012						where
3013							S: Serializer,
3014						{
3015							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3016								self.0, serializer,
3017							)
3018						}
3019					}
3020					&SerializeWith(&self.r#publisher_imprint)
3021				})?;
3022			} else {
3023				serialize_struct.skip_field("publisherImprint")?;
3024			}
3025			if !Vec::is_empty(&self.r#publishing_principles) {
3026				serialize_struct.serialize_field("publishingPrinciples", {
3027					struct SerializeWith<'a>(&'a Vec<PublishingPrinciplesProperty>);
3028					impl<'a> Serialize for SerializeWith<'a> {
3029						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3030						where
3031							S: Serializer,
3032						{
3033							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3034								self.0, serializer,
3035							)
3036						}
3037					}
3038					&SerializeWith(&self.r#publishing_principles)
3039				})?;
3040			} else {
3041				serialize_struct.skip_field("publishingPrinciples")?;
3042			}
3043			if !Vec::is_empty(&self.r#recorded_at) {
3044				serialize_struct.serialize_field("recordedAt", {
3045					struct SerializeWith<'a>(&'a Vec<RecordedAtProperty>);
3046					impl<'a> Serialize for SerializeWith<'a> {
3047						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3048						where
3049							S: Serializer,
3050						{
3051							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3052								self.0, serializer,
3053							)
3054						}
3055					}
3056					&SerializeWith(&self.r#recorded_at)
3057				})?;
3058			} else {
3059				serialize_struct.skip_field("recordedAt")?;
3060			}
3061			if !Vec::is_empty(&self.r#released_event) {
3062				serialize_struct.serialize_field("releasedEvent", {
3063					struct SerializeWith<'a>(&'a Vec<ReleasedEventProperty>);
3064					impl<'a> Serialize for SerializeWith<'a> {
3065						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3066						where
3067							S: Serializer,
3068						{
3069							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3070								self.0, serializer,
3071							)
3072						}
3073					}
3074					&SerializeWith(&self.r#released_event)
3075				})?;
3076			} else {
3077				serialize_struct.skip_field("releasedEvent")?;
3078			}
3079			if !Vec::is_empty(&self.r#review) {
3080				serialize_struct.serialize_field("review", {
3081					struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
3082					impl<'a> Serialize for SerializeWith<'a> {
3083						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3084						where
3085							S: Serializer,
3086						{
3087							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3088								self.0, serializer,
3089							)
3090						}
3091					}
3092					&SerializeWith(&self.r#review)
3093				})?;
3094			} else {
3095				serialize_struct.skip_field("review")?;
3096			}
3097			if !Vec::is_empty(&self.r#reviews) {
3098				serialize_struct.serialize_field("reviews", {
3099					struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
3100					impl<'a> Serialize for SerializeWith<'a> {
3101						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3102						where
3103							S: Serializer,
3104						{
3105							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3106								self.0, serializer,
3107							)
3108						}
3109					}
3110					&SerializeWith(&self.r#reviews)
3111				})?;
3112			} else {
3113				serialize_struct.skip_field("reviews")?;
3114			}
3115			if !Vec::is_empty(&self.r#schema_version) {
3116				serialize_struct.serialize_field("schemaVersion", {
3117					struct SerializeWith<'a>(&'a Vec<SchemaVersionProperty>);
3118					impl<'a> Serialize for SerializeWith<'a> {
3119						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3120						where
3121							S: Serializer,
3122						{
3123							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3124								self.0, serializer,
3125							)
3126						}
3127					}
3128					&SerializeWith(&self.r#schema_version)
3129				})?;
3130			} else {
3131				serialize_struct.skip_field("schemaVersion")?;
3132			}
3133			if !Vec::is_empty(&self.r#sd_date_published) {
3134				serialize_struct.serialize_field("sdDatePublished", {
3135					struct SerializeWith<'a>(&'a Vec<SdDatePublishedProperty>);
3136					impl<'a> Serialize for SerializeWith<'a> {
3137						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3138						where
3139							S: Serializer,
3140						{
3141							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3142								self.0, serializer,
3143							)
3144						}
3145					}
3146					&SerializeWith(&self.r#sd_date_published)
3147				})?;
3148			} else {
3149				serialize_struct.skip_field("sdDatePublished")?;
3150			}
3151			if !Vec::is_empty(&self.r#sd_license) {
3152				serialize_struct.serialize_field("sdLicense", {
3153					struct SerializeWith<'a>(&'a Vec<SdLicenseProperty>);
3154					impl<'a> Serialize for SerializeWith<'a> {
3155						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3156						where
3157							S: Serializer,
3158						{
3159							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3160								self.0, serializer,
3161							)
3162						}
3163					}
3164					&SerializeWith(&self.r#sd_license)
3165				})?;
3166			} else {
3167				serialize_struct.skip_field("sdLicense")?;
3168			}
3169			if !Vec::is_empty(&self.r#sd_publisher) {
3170				serialize_struct.serialize_field("sdPublisher", {
3171					struct SerializeWith<'a>(&'a Vec<SdPublisherProperty>);
3172					impl<'a> Serialize for SerializeWith<'a> {
3173						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3174						where
3175							S: Serializer,
3176						{
3177							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3178								self.0, serializer,
3179							)
3180						}
3181					}
3182					&SerializeWith(&self.r#sd_publisher)
3183				})?;
3184			} else {
3185				serialize_struct.skip_field("sdPublisher")?;
3186			}
3187			if !Vec::is_empty(&self.r#size) {
3188				serialize_struct.serialize_field("size", {
3189					struct SerializeWith<'a>(&'a Vec<SizeProperty>);
3190					impl<'a> Serialize for SerializeWith<'a> {
3191						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3192						where
3193							S: Serializer,
3194						{
3195							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3196								self.0, serializer,
3197							)
3198						}
3199					}
3200					&SerializeWith(&self.r#size)
3201				})?;
3202			} else {
3203				serialize_struct.skip_field("size")?;
3204			}
3205			if !Vec::is_empty(&self.r#source_organization) {
3206				serialize_struct.serialize_field("sourceOrganization", {
3207					struct SerializeWith<'a>(&'a Vec<SourceOrganizationProperty>);
3208					impl<'a> Serialize for SerializeWith<'a> {
3209						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3210						where
3211							S: Serializer,
3212						{
3213							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3214								self.0, serializer,
3215							)
3216						}
3217					}
3218					&SerializeWith(&self.r#source_organization)
3219				})?;
3220			} else {
3221				serialize_struct.skip_field("sourceOrganization")?;
3222			}
3223			if !Vec::is_empty(&self.r#spatial) {
3224				serialize_struct.serialize_field("spatial", {
3225					struct SerializeWith<'a>(&'a Vec<SpatialProperty>);
3226					impl<'a> Serialize for SerializeWith<'a> {
3227						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3228						where
3229							S: Serializer,
3230						{
3231							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3232								self.0, serializer,
3233							)
3234						}
3235					}
3236					&SerializeWith(&self.r#spatial)
3237				})?;
3238			} else {
3239				serialize_struct.skip_field("spatial")?;
3240			}
3241			if !Vec::is_empty(&self.r#spatial_coverage) {
3242				serialize_struct.serialize_field("spatialCoverage", {
3243					struct SerializeWith<'a>(&'a Vec<SpatialCoverageProperty>);
3244					impl<'a> Serialize for SerializeWith<'a> {
3245						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3246						where
3247							S: Serializer,
3248						{
3249							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3250								self.0, serializer,
3251							)
3252						}
3253					}
3254					&SerializeWith(&self.r#spatial_coverage)
3255				})?;
3256			} else {
3257				serialize_struct.skip_field("spatialCoverage")?;
3258			}
3259			if !Vec::is_empty(&self.r#sponsor) {
3260				serialize_struct.serialize_field("sponsor", {
3261					struct SerializeWith<'a>(&'a Vec<SponsorProperty>);
3262					impl<'a> Serialize for SerializeWith<'a> {
3263						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3264						where
3265							S: Serializer,
3266						{
3267							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3268								self.0, serializer,
3269							)
3270						}
3271					}
3272					&SerializeWith(&self.r#sponsor)
3273				})?;
3274			} else {
3275				serialize_struct.skip_field("sponsor")?;
3276			}
3277			if !Vec::is_empty(&self.r#teaches) {
3278				serialize_struct.serialize_field("teaches", {
3279					struct SerializeWith<'a>(&'a Vec<TeachesProperty>);
3280					impl<'a> Serialize for SerializeWith<'a> {
3281						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3282						where
3283							S: Serializer,
3284						{
3285							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3286								self.0, serializer,
3287							)
3288						}
3289					}
3290					&SerializeWith(&self.r#teaches)
3291				})?;
3292			} else {
3293				serialize_struct.skip_field("teaches")?;
3294			}
3295			if !Vec::is_empty(&self.r#temporal) {
3296				serialize_struct.serialize_field("temporal", {
3297					struct SerializeWith<'a>(&'a Vec<TemporalProperty>);
3298					impl<'a> Serialize for SerializeWith<'a> {
3299						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3300						where
3301							S: Serializer,
3302						{
3303							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3304								self.0, serializer,
3305							)
3306						}
3307					}
3308					&SerializeWith(&self.r#temporal)
3309				})?;
3310			} else {
3311				serialize_struct.skip_field("temporal")?;
3312			}
3313			if !Vec::is_empty(&self.r#temporal_coverage) {
3314				serialize_struct.serialize_field("temporalCoverage", {
3315					struct SerializeWith<'a>(&'a Vec<TemporalCoverageProperty>);
3316					impl<'a> Serialize for SerializeWith<'a> {
3317						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3318						where
3319							S: Serializer,
3320						{
3321							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3322								self.0, serializer,
3323							)
3324						}
3325					}
3326					&SerializeWith(&self.r#temporal_coverage)
3327				})?;
3328			} else {
3329				serialize_struct.skip_field("temporalCoverage")?;
3330			}
3331			if !Vec::is_empty(&self.r#text) {
3332				serialize_struct.serialize_field("text", {
3333					struct SerializeWith<'a>(&'a Vec<TextProperty>);
3334					impl<'a> Serialize for SerializeWith<'a> {
3335						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3336						where
3337							S: Serializer,
3338						{
3339							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3340								self.0, serializer,
3341							)
3342						}
3343					}
3344					&SerializeWith(&self.r#text)
3345				})?;
3346			} else {
3347				serialize_struct.skip_field("text")?;
3348			}
3349			if !Vec::is_empty(&self.r#thumbnail) {
3350				serialize_struct.serialize_field("thumbnail", {
3351					struct SerializeWith<'a>(&'a Vec<ThumbnailProperty>);
3352					impl<'a> Serialize for SerializeWith<'a> {
3353						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3354						where
3355							S: Serializer,
3356						{
3357							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3358								self.0, serializer,
3359							)
3360						}
3361					}
3362					&SerializeWith(&self.r#thumbnail)
3363				})?;
3364			} else {
3365				serialize_struct.skip_field("thumbnail")?;
3366			}
3367			if !Vec::is_empty(&self.r#thumbnail_url) {
3368				serialize_struct.serialize_field("thumbnailUrl", {
3369					struct SerializeWith<'a>(&'a Vec<ThumbnailUrlProperty>);
3370					impl<'a> Serialize for SerializeWith<'a> {
3371						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3372						where
3373							S: Serializer,
3374						{
3375							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3376								self.0, serializer,
3377							)
3378						}
3379					}
3380					&SerializeWith(&self.r#thumbnail_url)
3381				})?;
3382			} else {
3383				serialize_struct.skip_field("thumbnailUrl")?;
3384			}
3385			if !Vec::is_empty(&self.r#time_required) {
3386				serialize_struct.serialize_field("timeRequired", {
3387					struct SerializeWith<'a>(&'a Vec<TimeRequiredProperty>);
3388					impl<'a> Serialize for SerializeWith<'a> {
3389						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3390						where
3391							S: Serializer,
3392						{
3393							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3394								self.0, serializer,
3395							)
3396						}
3397					}
3398					&SerializeWith(&self.r#time_required)
3399				})?;
3400			} else {
3401				serialize_struct.skip_field("timeRequired")?;
3402			}
3403			if !Vec::is_empty(&self.r#translation_of_work) {
3404				serialize_struct.serialize_field("translationOfWork", {
3405					struct SerializeWith<'a>(&'a Vec<TranslationOfWorkProperty>);
3406					impl<'a> Serialize for SerializeWith<'a> {
3407						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3408						where
3409							S: Serializer,
3410						{
3411							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3412								self.0, serializer,
3413							)
3414						}
3415					}
3416					&SerializeWith(&self.r#translation_of_work)
3417				})?;
3418			} else {
3419				serialize_struct.skip_field("translationOfWork")?;
3420			}
3421			if !Vec::is_empty(&self.r#translator) {
3422				serialize_struct.serialize_field("translator", {
3423					struct SerializeWith<'a>(&'a Vec<TranslatorProperty>);
3424					impl<'a> Serialize for SerializeWith<'a> {
3425						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3426						where
3427							S: Serializer,
3428						{
3429							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3430								self.0, serializer,
3431							)
3432						}
3433					}
3434					&SerializeWith(&self.r#translator)
3435				})?;
3436			} else {
3437				serialize_struct.skip_field("translator")?;
3438			}
3439			if !Vec::is_empty(&self.r#typical_age_range) {
3440				serialize_struct.serialize_field("typicalAgeRange", {
3441					struct SerializeWith<'a>(&'a Vec<TypicalAgeRangeProperty>);
3442					impl<'a> Serialize for SerializeWith<'a> {
3443						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3444						where
3445							S: Serializer,
3446						{
3447							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3448								self.0, serializer,
3449							)
3450						}
3451					}
3452					&SerializeWith(&self.r#typical_age_range)
3453				})?;
3454			} else {
3455				serialize_struct.skip_field("typicalAgeRange")?;
3456			}
3457			if !Vec::is_empty(&self.r#usage_info) {
3458				serialize_struct.serialize_field("usageInfo", {
3459					struct SerializeWith<'a>(&'a Vec<UsageInfoProperty>);
3460					impl<'a> Serialize for SerializeWith<'a> {
3461						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3462						where
3463							S: Serializer,
3464						{
3465							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3466								self.0, serializer,
3467							)
3468						}
3469					}
3470					&SerializeWith(&self.r#usage_info)
3471				})?;
3472			} else {
3473				serialize_struct.skip_field("usageInfo")?;
3474			}
3475			if !Vec::is_empty(&self.r#version) {
3476				serialize_struct.serialize_field("version", {
3477					struct SerializeWith<'a>(&'a Vec<VersionProperty>);
3478					impl<'a> Serialize for SerializeWith<'a> {
3479						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3480						where
3481							S: Serializer,
3482						{
3483							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3484								self.0, serializer,
3485							)
3486						}
3487					}
3488					&SerializeWith(&self.r#version)
3489				})?;
3490			} else {
3491				serialize_struct.skip_field("version")?;
3492			}
3493			if !Vec::is_empty(&self.r#video) {
3494				serialize_struct.serialize_field("video", {
3495					struct SerializeWith<'a>(&'a Vec<VideoProperty>);
3496					impl<'a> Serialize for SerializeWith<'a> {
3497						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3498						where
3499							S: Serializer,
3500						{
3501							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3502								self.0, serializer,
3503							)
3504						}
3505					}
3506					&SerializeWith(&self.r#video)
3507				})?;
3508			} else {
3509				serialize_struct.skip_field("video")?;
3510			}
3511			if !Vec::is_empty(&self.r#work_example) {
3512				serialize_struct.serialize_field("workExample", {
3513					struct SerializeWith<'a>(&'a Vec<WorkExampleProperty>);
3514					impl<'a> Serialize for SerializeWith<'a> {
3515						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3516						where
3517							S: Serializer,
3518						{
3519							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3520								self.0, serializer,
3521							)
3522						}
3523					}
3524					&SerializeWith(&self.r#work_example)
3525				})?;
3526			} else {
3527				serialize_struct.skip_field("workExample")?;
3528			}
3529			if !Vec::is_empty(&self.r#work_translation) {
3530				serialize_struct.serialize_field("workTranslation", {
3531					struct SerializeWith<'a>(&'a Vec<WorkTranslationProperty>);
3532					impl<'a> Serialize for SerializeWith<'a> {
3533						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3534						where
3535							S: Serializer,
3536						{
3537							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3538								self.0, serializer,
3539							)
3540						}
3541					}
3542					&SerializeWith(&self.r#work_translation)
3543				})?;
3544			} else {
3545				serialize_struct.skip_field("workTranslation")?;
3546			}
3547			if !Vec::is_empty(&self.r#dateline) {
3548				serialize_struct.serialize_field("dateline", {
3549					struct SerializeWith<'a>(&'a Vec<DatelineProperty>);
3550					impl<'a> Serialize for SerializeWith<'a> {
3551						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3552						where
3553							S: Serializer,
3554						{
3555							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3556								self.0, serializer,
3557							)
3558						}
3559					}
3560					&SerializeWith(&self.r#dateline)
3561				})?;
3562			} else {
3563				serialize_struct.skip_field("dateline")?;
3564			}
3565			if !Vec::is_empty(&self.r#print_column) {
3566				serialize_struct.serialize_field("printColumn", {
3567					struct SerializeWith<'a>(&'a Vec<PrintColumnProperty>);
3568					impl<'a> Serialize for SerializeWith<'a> {
3569						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3570						where
3571							S: Serializer,
3572						{
3573							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3574								self.0, serializer,
3575							)
3576						}
3577					}
3578					&SerializeWith(&self.r#print_column)
3579				})?;
3580			} else {
3581				serialize_struct.skip_field("printColumn")?;
3582			}
3583			if !Vec::is_empty(&self.r#print_edition) {
3584				serialize_struct.serialize_field("printEdition", {
3585					struct SerializeWith<'a>(&'a Vec<PrintEditionProperty>);
3586					impl<'a> Serialize for SerializeWith<'a> {
3587						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3588						where
3589							S: Serializer,
3590						{
3591							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3592								self.0, serializer,
3593							)
3594						}
3595					}
3596					&SerializeWith(&self.r#print_edition)
3597				})?;
3598			} else {
3599				serialize_struct.skip_field("printEdition")?;
3600			}
3601			if !Vec::is_empty(&self.r#print_page) {
3602				serialize_struct.serialize_field("printPage", {
3603					struct SerializeWith<'a>(&'a Vec<PrintPageProperty>);
3604					impl<'a> Serialize for SerializeWith<'a> {
3605						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3606						where
3607							S: Serializer,
3608						{
3609							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3610								self.0, serializer,
3611							)
3612						}
3613					}
3614					&SerializeWith(&self.r#print_page)
3615				})?;
3616			} else {
3617				serialize_struct.skip_field("printPage")?;
3618			}
3619			if !Vec::is_empty(&self.r#print_section) {
3620				serialize_struct.serialize_field("printSection", {
3621					struct SerializeWith<'a>(&'a Vec<PrintSectionProperty>);
3622					impl<'a> Serialize for SerializeWith<'a> {
3623						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3624						where
3625							S: Serializer,
3626						{
3627							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3628								self.0, serializer,
3629							)
3630						}
3631					}
3632					&SerializeWith(&self.r#print_section)
3633				})?;
3634			} else {
3635				serialize_struct.skip_field("printSection")?;
3636			}
3637			if !Vec::is_empty(&self.r#associated_claim_review) {
3638				serialize_struct.serialize_field("associatedClaimReview", {
3639					struct SerializeWith<'a>(&'a Vec<AssociatedClaimReviewProperty>);
3640					impl<'a> Serialize for SerializeWith<'a> {
3641						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3642						where
3643							S: Serializer,
3644						{
3645							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3646								self.0, serializer,
3647							)
3648						}
3649					}
3650					&SerializeWith(&self.r#associated_claim_review)
3651				})?;
3652			} else {
3653				serialize_struct.skip_field("associatedClaimReview")?;
3654			}
3655			if !Vec::is_empty(&self.r#associated_media_review) {
3656				serialize_struct.serialize_field("associatedMediaReview", {
3657					struct SerializeWith<'a>(&'a Vec<AssociatedMediaReviewProperty>);
3658					impl<'a> Serialize for SerializeWith<'a> {
3659						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3660						where
3661							S: Serializer,
3662						{
3663							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3664								self.0, serializer,
3665							)
3666						}
3667					}
3668					&SerializeWith(&self.r#associated_media_review)
3669				})?;
3670			} else {
3671				serialize_struct.skip_field("associatedMediaReview")?;
3672			}
3673			if !Vec::is_empty(&self.r#associated_review) {
3674				serialize_struct.serialize_field("associatedReview", {
3675					struct SerializeWith<'a>(&'a Vec<AssociatedReviewProperty>);
3676					impl<'a> Serialize for SerializeWith<'a> {
3677						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3678						where
3679							S: Serializer,
3680						{
3681							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3682								self.0, serializer,
3683							)
3684						}
3685					}
3686					&SerializeWith(&self.r#associated_review)
3687				})?;
3688			} else {
3689				serialize_struct.skip_field("associatedReview")?;
3690			}
3691			if !Vec::is_empty(&self.r#item_reviewed) {
3692				serialize_struct.serialize_field("itemReviewed", {
3693					struct SerializeWith<'a>(&'a Vec<ItemReviewedProperty>);
3694					impl<'a> Serialize for SerializeWith<'a> {
3695						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3696						where
3697							S: Serializer,
3698						{
3699							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3700								self.0, serializer,
3701							)
3702						}
3703					}
3704					&SerializeWith(&self.r#item_reviewed)
3705				})?;
3706			} else {
3707				serialize_struct.skip_field("itemReviewed")?;
3708			}
3709			if !Vec::is_empty(&self.r#negative_notes) {
3710				serialize_struct.serialize_field("negativeNotes", {
3711					struct SerializeWith<'a>(&'a Vec<NegativeNotesProperty>);
3712					impl<'a> Serialize for SerializeWith<'a> {
3713						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3714						where
3715							S: Serializer,
3716						{
3717							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3718								self.0, serializer,
3719							)
3720						}
3721					}
3722					&SerializeWith(&self.r#negative_notes)
3723				})?;
3724			} else {
3725				serialize_struct.skip_field("negativeNotes")?;
3726			}
3727			if !Vec::is_empty(&self.r#positive_notes) {
3728				serialize_struct.serialize_field("positiveNotes", {
3729					struct SerializeWith<'a>(&'a Vec<PositiveNotesProperty>);
3730					impl<'a> Serialize for SerializeWith<'a> {
3731						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3732						where
3733							S: Serializer,
3734						{
3735							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3736								self.0, serializer,
3737							)
3738						}
3739					}
3740					&SerializeWith(&self.r#positive_notes)
3741				})?;
3742			} else {
3743				serialize_struct.skip_field("positiveNotes")?;
3744			}
3745			if !Vec::is_empty(&self.r#review_aspect) {
3746				serialize_struct.serialize_field("reviewAspect", {
3747					struct SerializeWith<'a>(&'a Vec<ReviewAspectProperty>);
3748					impl<'a> Serialize for SerializeWith<'a> {
3749						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3750						where
3751							S: Serializer,
3752						{
3753							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3754								self.0, serializer,
3755							)
3756						}
3757					}
3758					&SerializeWith(&self.r#review_aspect)
3759				})?;
3760			} else {
3761				serialize_struct.skip_field("reviewAspect")?;
3762			}
3763			if !Vec::is_empty(&self.r#review_body) {
3764				serialize_struct.serialize_field("reviewBody", {
3765					struct SerializeWith<'a>(&'a Vec<ReviewBodyProperty>);
3766					impl<'a> Serialize for SerializeWith<'a> {
3767						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3768						where
3769							S: Serializer,
3770						{
3771							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3772								self.0, serializer,
3773							)
3774						}
3775					}
3776					&SerializeWith(&self.r#review_body)
3777				})?;
3778			} else {
3779				serialize_struct.skip_field("reviewBody")?;
3780			}
3781			if !Vec::is_empty(&self.r#review_rating) {
3782				serialize_struct.serialize_field("reviewRating", {
3783					struct SerializeWith<'a>(&'a Vec<ReviewRatingProperty>);
3784					impl<'a> Serialize for SerializeWith<'a> {
3785						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3786						where
3787							S: Serializer,
3788						{
3789							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3790								self.0, serializer,
3791							)
3792						}
3793					}
3794					&SerializeWith(&self.r#review_rating)
3795				})?;
3796			} else {
3797				serialize_struct.skip_field("reviewRating")?;
3798			}
3799			if !Vec::is_empty(&self.r#additional_type) {
3800				serialize_struct.serialize_field("additionalType", {
3801					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
3802					impl<'a> Serialize for SerializeWith<'a> {
3803						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3804						where
3805							S: Serializer,
3806						{
3807							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3808								self.0, serializer,
3809							)
3810						}
3811					}
3812					&SerializeWith(&self.r#additional_type)
3813				})?;
3814			} else {
3815				serialize_struct.skip_field("additionalType")?;
3816			}
3817			if !Vec::is_empty(&self.r#alternate_name) {
3818				serialize_struct.serialize_field("alternateName", {
3819					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
3820					impl<'a> Serialize for SerializeWith<'a> {
3821						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3822						where
3823							S: Serializer,
3824						{
3825							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3826								self.0, serializer,
3827							)
3828						}
3829					}
3830					&SerializeWith(&self.r#alternate_name)
3831				})?;
3832			} else {
3833				serialize_struct.skip_field("alternateName")?;
3834			}
3835			if !Vec::is_empty(&self.r#description) {
3836				serialize_struct.serialize_field("description", {
3837					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
3838					impl<'a> Serialize for SerializeWith<'a> {
3839						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3840						where
3841							S: Serializer,
3842						{
3843							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3844								self.0, serializer,
3845							)
3846						}
3847					}
3848					&SerializeWith(&self.r#description)
3849				})?;
3850			} else {
3851				serialize_struct.skip_field("description")?;
3852			}
3853			if !Vec::is_empty(&self.r#disambiguating_description) {
3854				serialize_struct.serialize_field("disambiguatingDescription", {
3855					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
3856					impl<'a> Serialize for SerializeWith<'a> {
3857						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3858						where
3859							S: Serializer,
3860						{
3861							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3862								self.0, serializer,
3863							)
3864						}
3865					}
3866					&SerializeWith(&self.r#disambiguating_description)
3867				})?;
3868			} else {
3869				serialize_struct.skip_field("disambiguatingDescription")?;
3870			}
3871			if !Vec::is_empty(&self.r#identifier) {
3872				serialize_struct.serialize_field("identifier", {
3873					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
3874					impl<'a> Serialize for SerializeWith<'a> {
3875						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3876						where
3877							S: Serializer,
3878						{
3879							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3880								self.0, serializer,
3881							)
3882						}
3883					}
3884					&SerializeWith(&self.r#identifier)
3885				})?;
3886			} else {
3887				serialize_struct.skip_field("identifier")?;
3888			}
3889			if !Vec::is_empty(&self.r#image) {
3890				serialize_struct.serialize_field("image", {
3891					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
3892					impl<'a> Serialize for SerializeWith<'a> {
3893						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3894						where
3895							S: Serializer,
3896						{
3897							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3898								self.0, serializer,
3899							)
3900						}
3901					}
3902					&SerializeWith(&self.r#image)
3903				})?;
3904			} else {
3905				serialize_struct.skip_field("image")?;
3906			}
3907			if !Vec::is_empty(&self.r#main_entity_of_page) {
3908				serialize_struct.serialize_field("mainEntityOfPage", {
3909					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
3910					impl<'a> Serialize for SerializeWith<'a> {
3911						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3912						where
3913							S: Serializer,
3914						{
3915							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3916								self.0, serializer,
3917							)
3918						}
3919					}
3920					&SerializeWith(&self.r#main_entity_of_page)
3921				})?;
3922			} else {
3923				serialize_struct.skip_field("mainEntityOfPage")?;
3924			}
3925			if !Vec::is_empty(&self.r#name) {
3926				serialize_struct.serialize_field("name", {
3927					struct SerializeWith<'a>(&'a Vec<NameProperty>);
3928					impl<'a> Serialize for SerializeWith<'a> {
3929						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3930						where
3931							S: Serializer,
3932						{
3933							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3934								self.0, serializer,
3935							)
3936						}
3937					}
3938					&SerializeWith(&self.r#name)
3939				})?;
3940			} else {
3941				serialize_struct.skip_field("name")?;
3942			}
3943			if !Vec::is_empty(&self.r#potential_action) {
3944				serialize_struct.serialize_field("potentialAction", {
3945					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
3946					impl<'a> Serialize for SerializeWith<'a> {
3947						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3948						where
3949							S: Serializer,
3950						{
3951							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3952								self.0, serializer,
3953							)
3954						}
3955					}
3956					&SerializeWith(&self.r#potential_action)
3957				})?;
3958			} else {
3959				serialize_struct.skip_field("potentialAction")?;
3960			}
3961			if !Vec::is_empty(&self.r#same_as) {
3962				serialize_struct.serialize_field("sameAs", {
3963					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
3964					impl<'a> Serialize for SerializeWith<'a> {
3965						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3966						where
3967							S: Serializer,
3968						{
3969							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3970								self.0, serializer,
3971							)
3972						}
3973					}
3974					&SerializeWith(&self.r#same_as)
3975				})?;
3976			} else {
3977				serialize_struct.skip_field("sameAs")?;
3978			}
3979			if !Vec::is_empty(&self.r#subject_of) {
3980				serialize_struct.serialize_field("subjectOf", {
3981					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
3982					impl<'a> Serialize for SerializeWith<'a> {
3983						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3984						where
3985							S: Serializer,
3986						{
3987							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3988								self.0, serializer,
3989							)
3990						}
3991					}
3992					&SerializeWith(&self.r#subject_of)
3993				})?;
3994			} else {
3995				serialize_struct.skip_field("subjectOf")?;
3996			}
3997			if !Vec::is_empty(&self.r#url) {
3998				serialize_struct.serialize_field("url", {
3999					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
4000					impl<'a> Serialize for SerializeWith<'a> {
4001						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4002						where
4003							S: Serializer,
4004						{
4005							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4006								self.0, serializer,
4007							)
4008						}
4009					}
4010					&SerializeWith(&self.r#url)
4011				})?;
4012			} else {
4013				serialize_struct.skip_field("url")?;
4014			}
4015			serialize_struct.end()
4016		}
4017	}
4018	impl<'de> Deserialize<'de> for ReviewNewsArticle {
4019		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4020		where
4021			D: Deserializer<'de>,
4022		{
4023			enum Field {
4024				ArticleBody,
4025				ArticleSection,
4026				Backstory,
4027				PageEnd,
4028				PageStart,
4029				Pagination,
4030				Speakable,
4031				WordCount,
4032				About,
4033				Abstract,
4034				AccessMode,
4035				AccessModeSufficient,
4036				AccessibilityApi,
4037				AccessibilityControl,
4038				AccessibilityFeature,
4039				AccessibilityHazard,
4040				AccessibilitySummary,
4041				AccountablePerson,
4042				AcquireLicensePage,
4043				AggregateRating,
4044				AlternativeHeadline,
4045				ArchivedAt,
4046				Assesses,
4047				AssociatedMedia,
4048				Audience,
4049				Audio,
4050				Author,
4051				Award,
4052				Awards,
4053				Character,
4054				Citation,
4055				Comment,
4056				CommentCount,
4057				ConditionsOfAccess,
4058				ContentLocation,
4059				ContentRating,
4060				ContentReferenceTime,
4061				Contributor,
4062				CopyrightHolder,
4063				CopyrightNotice,
4064				CopyrightYear,
4065				Correction,
4066				CountryOfOrigin,
4067				CreativeWorkStatus,
4068				Creator,
4069				CreditText,
4070				DateCreated,
4071				DateModified,
4072				DatePublished,
4073				DiscussionUrl,
4074				EditEidr,
4075				Editor,
4076				EducationalAlignment,
4077				EducationalLevel,
4078				EducationalUse,
4079				Encoding,
4080				EncodingFormat,
4081				Encodings,
4082				ExampleOfWork,
4083				Expires,
4084				FileFormat,
4085				Funder,
4086				Funding,
4087				Genre,
4088				HasPart,
4089				Headline,
4090				InLanguage,
4091				InteractionStatistic,
4092				InteractivityType,
4093				InterpretedAsClaim,
4094				IsAccessibleForFree,
4095				IsBasedOn,
4096				IsBasedOnUrl,
4097				IsFamilyFriendly,
4098				IsPartOf,
4099				Keywords,
4100				LearningResourceType,
4101				License,
4102				LocationCreated,
4103				MainEntity,
4104				Maintainer,
4105				Material,
4106				MaterialExtent,
4107				Mentions,
4108				Offers,
4109				Pattern,
4110				Position,
4111				Producer,
4112				Provider,
4113				Publication,
4114				Publisher,
4115				PublisherImprint,
4116				PublishingPrinciples,
4117				RecordedAt,
4118				ReleasedEvent,
4119				Review,
4120				Reviews,
4121				SchemaVersion,
4122				SdDatePublished,
4123				SdLicense,
4124				SdPublisher,
4125				Size,
4126				SourceOrganization,
4127				Spatial,
4128				SpatialCoverage,
4129				Sponsor,
4130				Teaches,
4131				Temporal,
4132				TemporalCoverage,
4133				Text,
4134				Thumbnail,
4135				ThumbnailUrl,
4136				TimeRequired,
4137				TranslationOfWork,
4138				Translator,
4139				TypicalAgeRange,
4140				UsageInfo,
4141				Version,
4142				Video,
4143				WorkExample,
4144				WorkTranslation,
4145				Dateline,
4146				PrintColumn,
4147				PrintEdition,
4148				PrintPage,
4149				PrintSection,
4150				AssociatedClaimReview,
4151				AssociatedMediaReview,
4152				AssociatedReview,
4153				ItemReviewed,
4154				NegativeNotes,
4155				PositiveNotes,
4156				ReviewAspect,
4157				ReviewBody,
4158				ReviewRating,
4159				AdditionalType,
4160				AlternateName,
4161				Description,
4162				DisambiguatingDescription,
4163				Identifier,
4164				Image,
4165				MainEntityOfPage,
4166				Name,
4167				PotentialAction,
4168				SameAs,
4169				SubjectOf,
4170				Url,
4171				Ignore,
4172			}
4173			struct FieldVisitor;
4174			impl<'de> Visitor<'de> for FieldVisitor {
4175				type Value = Field;
4176				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
4177					formatter.write_str("field identifier")
4178				}
4179				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
4180				where
4181					E: de::Error,
4182				{
4183					match value {
4184						"articleBody" => Ok(Field::ArticleBody),
4185						"articleSection" => Ok(Field::ArticleSection),
4186						"backstory" => Ok(Field::Backstory),
4187						"pageEnd" => Ok(Field::PageEnd),
4188						"pageStart" => Ok(Field::PageStart),
4189						"pagination" => Ok(Field::Pagination),
4190						"speakable" => Ok(Field::Speakable),
4191						"wordCount" => Ok(Field::WordCount),
4192						"about" => Ok(Field::About),
4193						"abstract" => Ok(Field::Abstract),
4194						"accessMode" => Ok(Field::AccessMode),
4195						"accessModeSufficient" => Ok(Field::AccessModeSufficient),
4196						"accessibilityAPI" => Ok(Field::AccessibilityApi),
4197						"accessibilityControl" => Ok(Field::AccessibilityControl),
4198						"accessibilityFeature" => Ok(Field::AccessibilityFeature),
4199						"accessibilityHazard" => Ok(Field::AccessibilityHazard),
4200						"accessibilitySummary" => Ok(Field::AccessibilitySummary),
4201						"accountablePerson" => Ok(Field::AccountablePerson),
4202						"acquireLicensePage" => Ok(Field::AcquireLicensePage),
4203						"aggregateRating" => Ok(Field::AggregateRating),
4204						"alternativeHeadline" => Ok(Field::AlternativeHeadline),
4205						"archivedAt" => Ok(Field::ArchivedAt),
4206						"assesses" => Ok(Field::Assesses),
4207						"associatedMedia" => Ok(Field::AssociatedMedia),
4208						"audience" => Ok(Field::Audience),
4209						"audio" => Ok(Field::Audio),
4210						"author" => Ok(Field::Author),
4211						"award" => Ok(Field::Award),
4212						"awards" => Ok(Field::Awards),
4213						"character" => Ok(Field::Character),
4214						"citation" => Ok(Field::Citation),
4215						"comment" => Ok(Field::Comment),
4216						"commentCount" => Ok(Field::CommentCount),
4217						"conditionsOfAccess" => Ok(Field::ConditionsOfAccess),
4218						"contentLocation" => Ok(Field::ContentLocation),
4219						"contentRating" => Ok(Field::ContentRating),
4220						"contentReferenceTime" => Ok(Field::ContentReferenceTime),
4221						"contributor" => Ok(Field::Contributor),
4222						"copyrightHolder" => Ok(Field::CopyrightHolder),
4223						"copyrightNotice" => Ok(Field::CopyrightNotice),
4224						"copyrightYear" => Ok(Field::CopyrightYear),
4225						"correction" => Ok(Field::Correction),
4226						"countryOfOrigin" => Ok(Field::CountryOfOrigin),
4227						"creativeWorkStatus" => Ok(Field::CreativeWorkStatus),
4228						"creator" => Ok(Field::Creator),
4229						"creditText" => Ok(Field::CreditText),
4230						"dateCreated" => Ok(Field::DateCreated),
4231						"dateModified" => Ok(Field::DateModified),
4232						"datePublished" => Ok(Field::DatePublished),
4233						"discussionUrl" => Ok(Field::DiscussionUrl),
4234						"editEIDR" => Ok(Field::EditEidr),
4235						"editor" => Ok(Field::Editor),
4236						"educationalAlignment" => Ok(Field::EducationalAlignment),
4237						"educationalLevel" => Ok(Field::EducationalLevel),
4238						"educationalUse" => Ok(Field::EducationalUse),
4239						"encoding" => Ok(Field::Encoding),
4240						"encodingFormat" => Ok(Field::EncodingFormat),
4241						"encodings" => Ok(Field::Encodings),
4242						"exampleOfWork" => Ok(Field::ExampleOfWork),
4243						"expires" => Ok(Field::Expires),
4244						"fileFormat" => Ok(Field::FileFormat),
4245						"funder" => Ok(Field::Funder),
4246						"funding" => Ok(Field::Funding),
4247						"genre" => Ok(Field::Genre),
4248						"hasPart" => Ok(Field::HasPart),
4249						"headline" => Ok(Field::Headline),
4250						"inLanguage" => Ok(Field::InLanguage),
4251						"interactionStatistic" => Ok(Field::InteractionStatistic),
4252						"interactivityType" => Ok(Field::InteractivityType),
4253						"interpretedAsClaim" => Ok(Field::InterpretedAsClaim),
4254						"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
4255						"isBasedOn" => Ok(Field::IsBasedOn),
4256						"isBasedOnUrl" => Ok(Field::IsBasedOnUrl),
4257						"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
4258						"isPartOf" => Ok(Field::IsPartOf),
4259						"keywords" => Ok(Field::Keywords),
4260						"learningResourceType" => Ok(Field::LearningResourceType),
4261						"license" => Ok(Field::License),
4262						"locationCreated" => Ok(Field::LocationCreated),
4263						"mainEntity" => Ok(Field::MainEntity),
4264						"maintainer" => Ok(Field::Maintainer),
4265						"material" => Ok(Field::Material),
4266						"materialExtent" => Ok(Field::MaterialExtent),
4267						"mentions" => Ok(Field::Mentions),
4268						"offers" => Ok(Field::Offers),
4269						"pattern" => Ok(Field::Pattern),
4270						"position" => Ok(Field::Position),
4271						"producer" => Ok(Field::Producer),
4272						"provider" => Ok(Field::Provider),
4273						"publication" => Ok(Field::Publication),
4274						"publisher" => Ok(Field::Publisher),
4275						"publisherImprint" => Ok(Field::PublisherImprint),
4276						"publishingPrinciples" => Ok(Field::PublishingPrinciples),
4277						"recordedAt" => Ok(Field::RecordedAt),
4278						"releasedEvent" => Ok(Field::ReleasedEvent),
4279						"review" => Ok(Field::Review),
4280						"reviews" => Ok(Field::Reviews),
4281						"schemaVersion" => Ok(Field::SchemaVersion),
4282						"sdDatePublished" => Ok(Field::SdDatePublished),
4283						"sdLicense" => Ok(Field::SdLicense),
4284						"sdPublisher" => Ok(Field::SdPublisher),
4285						"size" => Ok(Field::Size),
4286						"sourceOrganization" => Ok(Field::SourceOrganization),
4287						"spatial" => Ok(Field::Spatial),
4288						"spatialCoverage" => Ok(Field::SpatialCoverage),
4289						"sponsor" => Ok(Field::Sponsor),
4290						"teaches" => Ok(Field::Teaches),
4291						"temporal" => Ok(Field::Temporal),
4292						"temporalCoverage" => Ok(Field::TemporalCoverage),
4293						"text" => Ok(Field::Text),
4294						"thumbnail" => Ok(Field::Thumbnail),
4295						"thumbnailUrl" => Ok(Field::ThumbnailUrl),
4296						"timeRequired" => Ok(Field::TimeRequired),
4297						"translationOfWork" => Ok(Field::TranslationOfWork),
4298						"translator" => Ok(Field::Translator),
4299						"typicalAgeRange" => Ok(Field::TypicalAgeRange),
4300						"usageInfo" => Ok(Field::UsageInfo),
4301						"version" => Ok(Field::Version),
4302						"video" => Ok(Field::Video),
4303						"workExample" => Ok(Field::WorkExample),
4304						"workTranslation" => Ok(Field::WorkTranslation),
4305						"dateline" => Ok(Field::Dateline),
4306						"printColumn" => Ok(Field::PrintColumn),
4307						"printEdition" => Ok(Field::PrintEdition),
4308						"printPage" => Ok(Field::PrintPage),
4309						"printSection" => Ok(Field::PrintSection),
4310						"associatedClaimReview" => Ok(Field::AssociatedClaimReview),
4311						"associatedMediaReview" => Ok(Field::AssociatedMediaReview),
4312						"associatedReview" => Ok(Field::AssociatedReview),
4313						"itemReviewed" => Ok(Field::ItemReviewed),
4314						"negativeNotes" => Ok(Field::NegativeNotes),
4315						"positiveNotes" => Ok(Field::PositiveNotes),
4316						"reviewAspect" => Ok(Field::ReviewAspect),
4317						"reviewBody" => Ok(Field::ReviewBody),
4318						"reviewRating" => Ok(Field::ReviewRating),
4319						"additionalType" => Ok(Field::AdditionalType),
4320						"alternateName" => Ok(Field::AlternateName),
4321						"description" => Ok(Field::Description),
4322						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
4323						"identifier" => Ok(Field::Identifier),
4324						"image" => Ok(Field::Image),
4325						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
4326						"name" => Ok(Field::Name),
4327						"potentialAction" => Ok(Field::PotentialAction),
4328						"sameAs" => Ok(Field::SameAs),
4329						"subjectOf" => Ok(Field::SubjectOf),
4330						"url" => Ok(Field::Url),
4331						"id" | "type" => Ok(Field::Ignore),
4332						_ => Err(de::Error::unknown_field(value, FIELDS)),
4333					}
4334				}
4335				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
4336				where
4337					E: de::Error,
4338				{
4339					match value {
4340						b"articleBody" => Ok(Field::ArticleBody),
4341						b"articleSection" => Ok(Field::ArticleSection),
4342						b"backstory" => Ok(Field::Backstory),
4343						b"pageEnd" => Ok(Field::PageEnd),
4344						b"pageStart" => Ok(Field::PageStart),
4345						b"pagination" => Ok(Field::Pagination),
4346						b"speakable" => Ok(Field::Speakable),
4347						b"wordCount" => Ok(Field::WordCount),
4348						b"about" => Ok(Field::About),
4349						b"abstract" => Ok(Field::Abstract),
4350						b"accessMode" => Ok(Field::AccessMode),
4351						b"accessModeSufficient" => Ok(Field::AccessModeSufficient),
4352						b"accessibilityAPI" => Ok(Field::AccessibilityApi),
4353						b"accessibilityControl" => Ok(Field::AccessibilityControl),
4354						b"accessibilityFeature" => Ok(Field::AccessibilityFeature),
4355						b"accessibilityHazard" => Ok(Field::AccessibilityHazard),
4356						b"accessibilitySummary" => Ok(Field::AccessibilitySummary),
4357						b"accountablePerson" => Ok(Field::AccountablePerson),
4358						b"acquireLicensePage" => Ok(Field::AcquireLicensePage),
4359						b"aggregateRating" => Ok(Field::AggregateRating),
4360						b"alternativeHeadline" => Ok(Field::AlternativeHeadline),
4361						b"archivedAt" => Ok(Field::ArchivedAt),
4362						b"assesses" => Ok(Field::Assesses),
4363						b"associatedMedia" => Ok(Field::AssociatedMedia),
4364						b"audience" => Ok(Field::Audience),
4365						b"audio" => Ok(Field::Audio),
4366						b"author" => Ok(Field::Author),
4367						b"award" => Ok(Field::Award),
4368						b"awards" => Ok(Field::Awards),
4369						b"character" => Ok(Field::Character),
4370						b"citation" => Ok(Field::Citation),
4371						b"comment" => Ok(Field::Comment),
4372						b"commentCount" => Ok(Field::CommentCount),
4373						b"conditionsOfAccess" => Ok(Field::ConditionsOfAccess),
4374						b"contentLocation" => Ok(Field::ContentLocation),
4375						b"contentRating" => Ok(Field::ContentRating),
4376						b"contentReferenceTime" => Ok(Field::ContentReferenceTime),
4377						b"contributor" => Ok(Field::Contributor),
4378						b"copyrightHolder" => Ok(Field::CopyrightHolder),
4379						b"copyrightNotice" => Ok(Field::CopyrightNotice),
4380						b"copyrightYear" => Ok(Field::CopyrightYear),
4381						b"correction" => Ok(Field::Correction),
4382						b"countryOfOrigin" => Ok(Field::CountryOfOrigin),
4383						b"creativeWorkStatus" => Ok(Field::CreativeWorkStatus),
4384						b"creator" => Ok(Field::Creator),
4385						b"creditText" => Ok(Field::CreditText),
4386						b"dateCreated" => Ok(Field::DateCreated),
4387						b"dateModified" => Ok(Field::DateModified),
4388						b"datePublished" => Ok(Field::DatePublished),
4389						b"discussionUrl" => Ok(Field::DiscussionUrl),
4390						b"editEIDR" => Ok(Field::EditEidr),
4391						b"editor" => Ok(Field::Editor),
4392						b"educationalAlignment" => Ok(Field::EducationalAlignment),
4393						b"educationalLevel" => Ok(Field::EducationalLevel),
4394						b"educationalUse" => Ok(Field::EducationalUse),
4395						b"encoding" => Ok(Field::Encoding),
4396						b"encodingFormat" => Ok(Field::EncodingFormat),
4397						b"encodings" => Ok(Field::Encodings),
4398						b"exampleOfWork" => Ok(Field::ExampleOfWork),
4399						b"expires" => Ok(Field::Expires),
4400						b"fileFormat" => Ok(Field::FileFormat),
4401						b"funder" => Ok(Field::Funder),
4402						b"funding" => Ok(Field::Funding),
4403						b"genre" => Ok(Field::Genre),
4404						b"hasPart" => Ok(Field::HasPart),
4405						b"headline" => Ok(Field::Headline),
4406						b"inLanguage" => Ok(Field::InLanguage),
4407						b"interactionStatistic" => Ok(Field::InteractionStatistic),
4408						b"interactivityType" => Ok(Field::InteractivityType),
4409						b"interpretedAsClaim" => Ok(Field::InterpretedAsClaim),
4410						b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
4411						b"isBasedOn" => Ok(Field::IsBasedOn),
4412						b"isBasedOnUrl" => Ok(Field::IsBasedOnUrl),
4413						b"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
4414						b"isPartOf" => Ok(Field::IsPartOf),
4415						b"keywords" => Ok(Field::Keywords),
4416						b"learningResourceType" => Ok(Field::LearningResourceType),
4417						b"license" => Ok(Field::License),
4418						b"locationCreated" => Ok(Field::LocationCreated),
4419						b"mainEntity" => Ok(Field::MainEntity),
4420						b"maintainer" => Ok(Field::Maintainer),
4421						b"material" => Ok(Field::Material),
4422						b"materialExtent" => Ok(Field::MaterialExtent),
4423						b"mentions" => Ok(Field::Mentions),
4424						b"offers" => Ok(Field::Offers),
4425						b"pattern" => Ok(Field::Pattern),
4426						b"position" => Ok(Field::Position),
4427						b"producer" => Ok(Field::Producer),
4428						b"provider" => Ok(Field::Provider),
4429						b"publication" => Ok(Field::Publication),
4430						b"publisher" => Ok(Field::Publisher),
4431						b"publisherImprint" => Ok(Field::PublisherImprint),
4432						b"publishingPrinciples" => Ok(Field::PublishingPrinciples),
4433						b"recordedAt" => Ok(Field::RecordedAt),
4434						b"releasedEvent" => Ok(Field::ReleasedEvent),
4435						b"review" => Ok(Field::Review),
4436						b"reviews" => Ok(Field::Reviews),
4437						b"schemaVersion" => Ok(Field::SchemaVersion),
4438						b"sdDatePublished" => Ok(Field::SdDatePublished),
4439						b"sdLicense" => Ok(Field::SdLicense),
4440						b"sdPublisher" => Ok(Field::SdPublisher),
4441						b"size" => Ok(Field::Size),
4442						b"sourceOrganization" => Ok(Field::SourceOrganization),
4443						b"spatial" => Ok(Field::Spatial),
4444						b"spatialCoverage" => Ok(Field::SpatialCoverage),
4445						b"sponsor" => Ok(Field::Sponsor),
4446						b"teaches" => Ok(Field::Teaches),
4447						b"temporal" => Ok(Field::Temporal),
4448						b"temporalCoverage" => Ok(Field::TemporalCoverage),
4449						b"text" => Ok(Field::Text),
4450						b"thumbnail" => Ok(Field::Thumbnail),
4451						b"thumbnailUrl" => Ok(Field::ThumbnailUrl),
4452						b"timeRequired" => Ok(Field::TimeRequired),
4453						b"translationOfWork" => Ok(Field::TranslationOfWork),
4454						b"translator" => Ok(Field::Translator),
4455						b"typicalAgeRange" => Ok(Field::TypicalAgeRange),
4456						b"usageInfo" => Ok(Field::UsageInfo),
4457						b"version" => Ok(Field::Version),
4458						b"video" => Ok(Field::Video),
4459						b"workExample" => Ok(Field::WorkExample),
4460						b"workTranslation" => Ok(Field::WorkTranslation),
4461						b"dateline" => Ok(Field::Dateline),
4462						b"printColumn" => Ok(Field::PrintColumn),
4463						b"printEdition" => Ok(Field::PrintEdition),
4464						b"printPage" => Ok(Field::PrintPage),
4465						b"printSection" => Ok(Field::PrintSection),
4466						b"associatedClaimReview" => Ok(Field::AssociatedClaimReview),
4467						b"associatedMediaReview" => Ok(Field::AssociatedMediaReview),
4468						b"associatedReview" => Ok(Field::AssociatedReview),
4469						b"itemReviewed" => Ok(Field::ItemReviewed),
4470						b"negativeNotes" => Ok(Field::NegativeNotes),
4471						b"positiveNotes" => Ok(Field::PositiveNotes),
4472						b"reviewAspect" => Ok(Field::ReviewAspect),
4473						b"reviewBody" => Ok(Field::ReviewBody),
4474						b"reviewRating" => Ok(Field::ReviewRating),
4475						b"additionalType" => Ok(Field::AdditionalType),
4476						b"alternateName" => Ok(Field::AlternateName),
4477						b"description" => Ok(Field::Description),
4478						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
4479						b"identifier" => Ok(Field::Identifier),
4480						b"image" => Ok(Field::Image),
4481						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
4482						b"name" => Ok(Field::Name),
4483						b"potentialAction" => Ok(Field::PotentialAction),
4484						b"sameAs" => Ok(Field::SameAs),
4485						b"subjectOf" => Ok(Field::SubjectOf),
4486						b"url" => Ok(Field::Url),
4487						b"id" | b"type" => Ok(Field::Ignore),
4488						_ => {
4489							let value = &String::from_utf8_lossy(value);
4490							Err(de::Error::unknown_field(value, FIELDS))
4491						}
4492					}
4493				}
4494			}
4495			impl<'de> Deserialize<'de> for Field {
4496				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4497				where
4498					D: Deserializer<'de>,
4499				{
4500					deserializer.deserialize_identifier(FieldVisitor)
4501				}
4502			}
4503			struct ClassVisitor;
4504			impl<'de> Visitor<'de> for ClassVisitor {
4505				type Value = ReviewNewsArticle;
4506				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
4507					formatter.write_str("schema.org schema ReviewNewsArticle")
4508				}
4509				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
4510				where
4511					A: de::MapAccess<'de>,
4512				{
4513					let mut r#article_body_property = None;
4514					let mut r#article_section_property = None;
4515					let mut r#backstory_property = None;
4516					let mut r#page_end_property = None;
4517					let mut r#page_start_property = None;
4518					let mut r#pagination_property = None;
4519					let mut r#speakable_property = None;
4520					let mut r#word_count_property = None;
4521					let mut r#about_property = None;
4522					let mut r#abstract_property = None;
4523					let mut r#access_mode_property = None;
4524					let mut r#access_mode_sufficient_property = None;
4525					let mut r#accessibility_api_property = None;
4526					let mut r#accessibility_control_property = None;
4527					let mut r#accessibility_feature_property = None;
4528					let mut r#accessibility_hazard_property = None;
4529					let mut r#accessibility_summary_property = None;
4530					let mut r#accountable_person_property = None;
4531					let mut r#acquire_license_page_property = None;
4532					let mut r#aggregate_rating_property = None;
4533					let mut r#alternative_headline_property = None;
4534					let mut r#archived_at_property = None;
4535					let mut r#assesses_property = None;
4536					let mut r#associated_media_property = None;
4537					let mut r#audience_property = None;
4538					let mut r#audio_property = None;
4539					let mut r#author_property = None;
4540					let mut r#award_property = None;
4541					let mut r#awards_property = None;
4542					let mut r#character_property = None;
4543					let mut r#citation_property = None;
4544					let mut r#comment_property = None;
4545					let mut r#comment_count_property = None;
4546					let mut r#conditions_of_access_property = None;
4547					let mut r#content_location_property = None;
4548					let mut r#content_rating_property = None;
4549					let mut r#content_reference_time_property = None;
4550					let mut r#contributor_property = None;
4551					let mut r#copyright_holder_property = None;
4552					let mut r#copyright_notice_property = None;
4553					let mut r#copyright_year_property = None;
4554					let mut r#correction_property = None;
4555					let mut r#country_of_origin_property = None;
4556					let mut r#creative_work_status_property = None;
4557					let mut r#creator_property = None;
4558					let mut r#credit_text_property = None;
4559					let mut r#date_created_property = None;
4560					let mut r#date_modified_property = None;
4561					let mut r#date_published_property = None;
4562					let mut r#discussion_url_property = None;
4563					let mut r#edit_eidr_property = None;
4564					let mut r#editor_property = None;
4565					let mut r#educational_alignment_property = None;
4566					let mut r#educational_level_property = None;
4567					let mut r#educational_use_property = None;
4568					let mut r#encoding_property = None;
4569					let mut r#encoding_format_property = None;
4570					let mut r#encodings_property = None;
4571					let mut r#example_of_work_property = None;
4572					let mut r#expires_property = None;
4573					let mut r#file_format_property = None;
4574					let mut r#funder_property = None;
4575					let mut r#funding_property = None;
4576					let mut r#genre_property = None;
4577					let mut r#has_part_property = None;
4578					let mut r#headline_property = None;
4579					let mut r#in_language_property = None;
4580					let mut r#interaction_statistic_property = None;
4581					let mut r#interactivity_type_property = None;
4582					let mut r#interpreted_as_claim_property = None;
4583					let mut r#is_accessible_for_free_property = None;
4584					let mut r#is_based_on_property = None;
4585					let mut r#is_based_on_url_property = None;
4586					let mut r#is_family_friendly_property = None;
4587					let mut r#is_part_of_property = None;
4588					let mut r#keywords_property = None;
4589					let mut r#learning_resource_type_property = None;
4590					let mut r#license_property = None;
4591					let mut r#location_created_property = None;
4592					let mut r#main_entity_property = None;
4593					let mut r#maintainer_property = None;
4594					let mut r#material_property = None;
4595					let mut r#material_extent_property = None;
4596					let mut r#mentions_property = None;
4597					let mut r#offers_property = None;
4598					let mut r#pattern_property = None;
4599					let mut r#position_property = None;
4600					let mut r#producer_property = None;
4601					let mut r#provider_property = None;
4602					let mut r#publication_property = None;
4603					let mut r#publisher_property = None;
4604					let mut r#publisher_imprint_property = None;
4605					let mut r#publishing_principles_property = None;
4606					let mut r#recorded_at_property = None;
4607					let mut r#released_event_property = None;
4608					let mut r#review_property = None;
4609					let mut r#reviews_property = None;
4610					let mut r#schema_version_property = None;
4611					let mut r#sd_date_published_property = None;
4612					let mut r#sd_license_property = None;
4613					let mut r#sd_publisher_property = None;
4614					let mut r#size_property = None;
4615					let mut r#source_organization_property = None;
4616					let mut r#spatial_property = None;
4617					let mut r#spatial_coverage_property = None;
4618					let mut r#sponsor_property = None;
4619					let mut r#teaches_property = None;
4620					let mut r#temporal_property = None;
4621					let mut r#temporal_coverage_property = None;
4622					let mut r#text_property = None;
4623					let mut r#thumbnail_property = None;
4624					let mut r#thumbnail_url_property = None;
4625					let mut r#time_required_property = None;
4626					let mut r#translation_of_work_property = None;
4627					let mut r#translator_property = None;
4628					let mut r#typical_age_range_property = None;
4629					let mut r#usage_info_property = None;
4630					let mut r#version_property = None;
4631					let mut r#video_property = None;
4632					let mut r#work_example_property = None;
4633					let mut r#work_translation_property = None;
4634					let mut r#dateline_property = None;
4635					let mut r#print_column_property = None;
4636					let mut r#print_edition_property = None;
4637					let mut r#print_page_property = None;
4638					let mut r#print_section_property = None;
4639					let mut r#associated_claim_review_property = None;
4640					let mut r#associated_media_review_property = None;
4641					let mut r#associated_review_property = None;
4642					let mut r#item_reviewed_property = None;
4643					let mut r#negative_notes_property = None;
4644					let mut r#positive_notes_property = None;
4645					let mut r#review_aspect_property = None;
4646					let mut r#review_body_property = None;
4647					let mut r#review_rating_property = None;
4648					let mut r#additional_type_property = None;
4649					let mut r#alternate_name_property = None;
4650					let mut r#description_property = None;
4651					let mut r#disambiguating_description_property = None;
4652					let mut r#identifier_property = None;
4653					let mut r#image_property = None;
4654					let mut r#main_entity_of_page_property = None;
4655					let mut r#name_property = None;
4656					let mut r#potential_action_property = None;
4657					let mut r#same_as_property = None;
4658					let mut r#subject_of_property = None;
4659					let mut r#url_property = None;
4660					while let Some(key) = map.next_key::<Field>()? {
4661						match key {
4662							Field::ArticleBody => {
4663								if r#article_body_property.is_some() {
4664									return Err(<A::Error as de::Error>::duplicate_field(
4665										"articleBody",
4666									));
4667								}
4668								r#article_body_property = Some({
4669									struct DeserializeWith(Vec<ArticleBodyProperty>);
4670									impl<'de> Deserialize<'de> for DeserializeWith {
4671										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4672										where
4673											D: Deserializer<'de>,
4674										{
4675											Ok(DeserializeWith(serde_with::As::<
4676												serde_with::OneOrMany<serde_with::Same>,
4677											>::deserialize(deserializer)?))
4678										}
4679									}
4680									match map.next_value::<DeserializeWith>() {
4681										Ok(deserialize_with) => deserialize_with.0,
4682										Err(err) => {
4683											return Err(err);
4684										}
4685									}
4686								});
4687							}
4688							Field::ArticleSection => {
4689								if r#article_section_property.is_some() {
4690									return Err(<A::Error as de::Error>::duplicate_field(
4691										"articleSection",
4692									));
4693								}
4694								r#article_section_property = Some({
4695									struct DeserializeWith(Vec<ArticleSectionProperty>);
4696									impl<'de> Deserialize<'de> for DeserializeWith {
4697										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4698										where
4699											D: Deserializer<'de>,
4700										{
4701											Ok(DeserializeWith(serde_with::As::<
4702												serde_with::OneOrMany<serde_with::Same>,
4703											>::deserialize(deserializer)?))
4704										}
4705									}
4706									match map.next_value::<DeserializeWith>() {
4707										Ok(deserialize_with) => deserialize_with.0,
4708										Err(err) => {
4709											return Err(err);
4710										}
4711									}
4712								});
4713							}
4714							Field::Backstory => {
4715								if r#backstory_property.is_some() {
4716									return Err(<A::Error as de::Error>::duplicate_field(
4717										"backstory",
4718									));
4719								}
4720								r#backstory_property = Some({
4721									struct DeserializeWith(Vec<BackstoryProperty>);
4722									impl<'de> Deserialize<'de> for DeserializeWith {
4723										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4724										where
4725											D: Deserializer<'de>,
4726										{
4727											Ok(DeserializeWith(serde_with::As::<
4728												serde_with::OneOrMany<serde_with::Same>,
4729											>::deserialize(deserializer)?))
4730										}
4731									}
4732									match map.next_value::<DeserializeWith>() {
4733										Ok(deserialize_with) => deserialize_with.0,
4734										Err(err) => {
4735											return Err(err);
4736										}
4737									}
4738								});
4739							}
4740							Field::PageEnd => {
4741								if r#page_end_property.is_some() {
4742									return Err(<A::Error as de::Error>::duplicate_field(
4743										"pageEnd",
4744									));
4745								}
4746								r#page_end_property = Some({
4747									struct DeserializeWith(Vec<PageEndProperty>);
4748									impl<'de> Deserialize<'de> for DeserializeWith {
4749										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4750										where
4751											D: Deserializer<'de>,
4752										{
4753											Ok(DeserializeWith(serde_with::As::<
4754												serde_with::OneOrMany<serde_with::Same>,
4755											>::deserialize(deserializer)?))
4756										}
4757									}
4758									match map.next_value::<DeserializeWith>() {
4759										Ok(deserialize_with) => deserialize_with.0,
4760										Err(err) => {
4761											return Err(err);
4762										}
4763									}
4764								});
4765							}
4766							Field::PageStart => {
4767								if r#page_start_property.is_some() {
4768									return Err(<A::Error as de::Error>::duplicate_field(
4769										"pageStart",
4770									));
4771								}
4772								r#page_start_property = Some({
4773									struct DeserializeWith(Vec<PageStartProperty>);
4774									impl<'de> Deserialize<'de> for DeserializeWith {
4775										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4776										where
4777											D: Deserializer<'de>,
4778										{
4779											Ok(DeserializeWith(serde_with::As::<
4780												serde_with::OneOrMany<serde_with::Same>,
4781											>::deserialize(deserializer)?))
4782										}
4783									}
4784									match map.next_value::<DeserializeWith>() {
4785										Ok(deserialize_with) => deserialize_with.0,
4786										Err(err) => {
4787											return Err(err);
4788										}
4789									}
4790								});
4791							}
4792							Field::Pagination => {
4793								if r#pagination_property.is_some() {
4794									return Err(<A::Error as de::Error>::duplicate_field(
4795										"pagination",
4796									));
4797								}
4798								r#pagination_property = Some({
4799									struct DeserializeWith(Vec<PaginationProperty>);
4800									impl<'de> Deserialize<'de> for DeserializeWith {
4801										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4802										where
4803											D: Deserializer<'de>,
4804										{
4805											Ok(DeserializeWith(serde_with::As::<
4806												serde_with::OneOrMany<serde_with::Same>,
4807											>::deserialize(deserializer)?))
4808										}
4809									}
4810									match map.next_value::<DeserializeWith>() {
4811										Ok(deserialize_with) => deserialize_with.0,
4812										Err(err) => {
4813											return Err(err);
4814										}
4815									}
4816								});
4817							}
4818							Field::Speakable => {
4819								if r#speakable_property.is_some() {
4820									return Err(<A::Error as de::Error>::duplicate_field(
4821										"speakable",
4822									));
4823								}
4824								r#speakable_property = Some({
4825									struct DeserializeWith(Vec<SpeakableProperty>);
4826									impl<'de> Deserialize<'de> for DeserializeWith {
4827										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4828										where
4829											D: Deserializer<'de>,
4830										{
4831											Ok(DeserializeWith(serde_with::As::<
4832												serde_with::OneOrMany<serde_with::Same>,
4833											>::deserialize(deserializer)?))
4834										}
4835									}
4836									match map.next_value::<DeserializeWith>() {
4837										Ok(deserialize_with) => deserialize_with.0,
4838										Err(err) => {
4839											return Err(err);
4840										}
4841									}
4842								});
4843							}
4844							Field::WordCount => {
4845								if r#word_count_property.is_some() {
4846									return Err(<A::Error as de::Error>::duplicate_field(
4847										"wordCount",
4848									));
4849								}
4850								r#word_count_property = Some({
4851									struct DeserializeWith(Vec<WordCountProperty>);
4852									impl<'de> Deserialize<'de> for DeserializeWith {
4853										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4854										where
4855											D: Deserializer<'de>,
4856										{
4857											Ok(DeserializeWith(serde_with::As::<
4858												serde_with::OneOrMany<serde_with::Same>,
4859											>::deserialize(deserializer)?))
4860										}
4861									}
4862									match map.next_value::<DeserializeWith>() {
4863										Ok(deserialize_with) => deserialize_with.0,
4864										Err(err) => {
4865											return Err(err);
4866										}
4867									}
4868								});
4869							}
4870							Field::About => {
4871								if r#about_property.is_some() {
4872									return Err(<A::Error as de::Error>::duplicate_field("about"));
4873								}
4874								r#about_property = Some({
4875									struct DeserializeWith(Vec<AboutProperty>);
4876									impl<'de> Deserialize<'de> for DeserializeWith {
4877										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4878										where
4879											D: Deserializer<'de>,
4880										{
4881											Ok(DeserializeWith(serde_with::As::<
4882												serde_with::OneOrMany<serde_with::Same>,
4883											>::deserialize(deserializer)?))
4884										}
4885									}
4886									match map.next_value::<DeserializeWith>() {
4887										Ok(deserialize_with) => deserialize_with.0,
4888										Err(err) => {
4889											return Err(err);
4890										}
4891									}
4892								});
4893							}
4894							Field::Abstract => {
4895								if r#abstract_property.is_some() {
4896									return Err(<A::Error as de::Error>::duplicate_field(
4897										"abstract",
4898									));
4899								}
4900								r#abstract_property = Some({
4901									struct DeserializeWith(Vec<AbstractProperty>);
4902									impl<'de> Deserialize<'de> for DeserializeWith {
4903										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4904										where
4905											D: Deserializer<'de>,
4906										{
4907											Ok(DeserializeWith(serde_with::As::<
4908												serde_with::OneOrMany<serde_with::Same>,
4909											>::deserialize(deserializer)?))
4910										}
4911									}
4912									match map.next_value::<DeserializeWith>() {
4913										Ok(deserialize_with) => deserialize_with.0,
4914										Err(err) => {
4915											return Err(err);
4916										}
4917									}
4918								});
4919							}
4920							Field::AccessMode => {
4921								if r#access_mode_property.is_some() {
4922									return Err(<A::Error as de::Error>::duplicate_field(
4923										"accessMode",
4924									));
4925								}
4926								r#access_mode_property = Some({
4927									struct DeserializeWith(Vec<AccessModeProperty>);
4928									impl<'de> Deserialize<'de> for DeserializeWith {
4929										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4930										where
4931											D: Deserializer<'de>,
4932										{
4933											Ok(DeserializeWith(serde_with::As::<
4934												serde_with::OneOrMany<serde_with::Same>,
4935											>::deserialize(deserializer)?))
4936										}
4937									}
4938									match map.next_value::<DeserializeWith>() {
4939										Ok(deserialize_with) => deserialize_with.0,
4940										Err(err) => {
4941											return Err(err);
4942										}
4943									}
4944								});
4945							}
4946							Field::AccessModeSufficient => {
4947								if r#access_mode_sufficient_property.is_some() {
4948									return Err(<A::Error as de::Error>::duplicate_field(
4949										"accessModeSufficient",
4950									));
4951								}
4952								r#access_mode_sufficient_property = Some({
4953									struct DeserializeWith(Vec<AccessModeSufficientProperty>);
4954									impl<'de> Deserialize<'de> for DeserializeWith {
4955										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4956										where
4957											D: Deserializer<'de>,
4958										{
4959											Ok(DeserializeWith(serde_with::As::<
4960												serde_with::OneOrMany<serde_with::Same>,
4961											>::deserialize(deserializer)?))
4962										}
4963									}
4964									match map.next_value::<DeserializeWith>() {
4965										Ok(deserialize_with) => deserialize_with.0,
4966										Err(err) => {
4967											return Err(err);
4968										}
4969									}
4970								});
4971							}
4972							Field::AccessibilityApi => {
4973								if r#accessibility_api_property.is_some() {
4974									return Err(<A::Error as de::Error>::duplicate_field(
4975										"accessibilityAPI",
4976									));
4977								}
4978								r#accessibility_api_property = Some({
4979									struct DeserializeWith(Vec<AccessibilityApiProperty>);
4980									impl<'de> Deserialize<'de> for DeserializeWith {
4981										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4982										where
4983											D: Deserializer<'de>,
4984										{
4985											Ok(DeserializeWith(serde_with::As::<
4986												serde_with::OneOrMany<serde_with::Same>,
4987											>::deserialize(deserializer)?))
4988										}
4989									}
4990									match map.next_value::<DeserializeWith>() {
4991										Ok(deserialize_with) => deserialize_with.0,
4992										Err(err) => {
4993											return Err(err);
4994										}
4995									}
4996								});
4997							}
4998							Field::AccessibilityControl => {
4999								if r#accessibility_control_property.is_some() {
5000									return Err(<A::Error as de::Error>::duplicate_field(
5001										"accessibilityControl",
5002									));
5003								}
5004								r#accessibility_control_property = Some({
5005									struct DeserializeWith(Vec<AccessibilityControlProperty>);
5006									impl<'de> Deserialize<'de> for DeserializeWith {
5007										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5008										where
5009											D: Deserializer<'de>,
5010										{
5011											Ok(DeserializeWith(serde_with::As::<
5012												serde_with::OneOrMany<serde_with::Same>,
5013											>::deserialize(deserializer)?))
5014										}
5015									}
5016									match map.next_value::<DeserializeWith>() {
5017										Ok(deserialize_with) => deserialize_with.0,
5018										Err(err) => {
5019											return Err(err);
5020										}
5021									}
5022								});
5023							}
5024							Field::AccessibilityFeature => {
5025								if r#accessibility_feature_property.is_some() {
5026									return Err(<A::Error as de::Error>::duplicate_field(
5027										"accessibilityFeature",
5028									));
5029								}
5030								r#accessibility_feature_property = Some({
5031									struct DeserializeWith(Vec<AccessibilityFeatureProperty>);
5032									impl<'de> Deserialize<'de> for DeserializeWith {
5033										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5034										where
5035											D: Deserializer<'de>,
5036										{
5037											Ok(DeserializeWith(serde_with::As::<
5038												serde_with::OneOrMany<serde_with::Same>,
5039											>::deserialize(deserializer)?))
5040										}
5041									}
5042									match map.next_value::<DeserializeWith>() {
5043										Ok(deserialize_with) => deserialize_with.0,
5044										Err(err) => {
5045											return Err(err);
5046										}
5047									}
5048								});
5049							}
5050							Field::AccessibilityHazard => {
5051								if r#accessibility_hazard_property.is_some() {
5052									return Err(<A::Error as de::Error>::duplicate_field(
5053										"accessibilityHazard",
5054									));
5055								}
5056								r#accessibility_hazard_property = Some({
5057									struct DeserializeWith(Vec<AccessibilityHazardProperty>);
5058									impl<'de> Deserialize<'de> for DeserializeWith {
5059										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5060										where
5061											D: Deserializer<'de>,
5062										{
5063											Ok(DeserializeWith(serde_with::As::<
5064												serde_with::OneOrMany<serde_with::Same>,
5065											>::deserialize(deserializer)?))
5066										}
5067									}
5068									match map.next_value::<DeserializeWith>() {
5069										Ok(deserialize_with) => deserialize_with.0,
5070										Err(err) => {
5071											return Err(err);
5072										}
5073									}
5074								});
5075							}
5076							Field::AccessibilitySummary => {
5077								if r#accessibility_summary_property.is_some() {
5078									return Err(<A::Error as de::Error>::duplicate_field(
5079										"accessibilitySummary",
5080									));
5081								}
5082								r#accessibility_summary_property = Some({
5083									struct DeserializeWith(Vec<AccessibilitySummaryProperty>);
5084									impl<'de> Deserialize<'de> for DeserializeWith {
5085										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5086										where
5087											D: Deserializer<'de>,
5088										{
5089											Ok(DeserializeWith(serde_with::As::<
5090												serde_with::OneOrMany<serde_with::Same>,
5091											>::deserialize(deserializer)?))
5092										}
5093									}
5094									match map.next_value::<DeserializeWith>() {
5095										Ok(deserialize_with) => deserialize_with.0,
5096										Err(err) => {
5097											return Err(err);
5098										}
5099									}
5100								});
5101							}
5102							Field::AccountablePerson => {
5103								if r#accountable_person_property.is_some() {
5104									return Err(<A::Error as de::Error>::duplicate_field(
5105										"accountablePerson",
5106									));
5107								}
5108								r#accountable_person_property = Some({
5109									struct DeserializeWith(Vec<AccountablePersonProperty>);
5110									impl<'de> Deserialize<'de> for DeserializeWith {
5111										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5112										where
5113											D: Deserializer<'de>,
5114										{
5115											Ok(DeserializeWith(serde_with::As::<
5116												serde_with::OneOrMany<serde_with::Same>,
5117											>::deserialize(deserializer)?))
5118										}
5119									}
5120									match map.next_value::<DeserializeWith>() {
5121										Ok(deserialize_with) => deserialize_with.0,
5122										Err(err) => {
5123											return Err(err);
5124										}
5125									}
5126								});
5127							}
5128							Field::AcquireLicensePage => {
5129								if r#acquire_license_page_property.is_some() {
5130									return Err(<A::Error as de::Error>::duplicate_field(
5131										"acquireLicensePage",
5132									));
5133								}
5134								r#acquire_license_page_property = Some({
5135									struct DeserializeWith(Vec<AcquireLicensePageProperty>);
5136									impl<'de> Deserialize<'de> for DeserializeWith {
5137										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5138										where
5139											D: Deserializer<'de>,
5140										{
5141											Ok(DeserializeWith(serde_with::As::<
5142												serde_with::OneOrMany<serde_with::Same>,
5143											>::deserialize(deserializer)?))
5144										}
5145									}
5146									match map.next_value::<DeserializeWith>() {
5147										Ok(deserialize_with) => deserialize_with.0,
5148										Err(err) => {
5149											return Err(err);
5150										}
5151									}
5152								});
5153							}
5154							Field::AggregateRating => {
5155								if r#aggregate_rating_property.is_some() {
5156									return Err(<A::Error as de::Error>::duplicate_field(
5157										"aggregateRating",
5158									));
5159								}
5160								r#aggregate_rating_property = Some({
5161									struct DeserializeWith(Vec<AggregateRatingProperty>);
5162									impl<'de> Deserialize<'de> for DeserializeWith {
5163										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5164										where
5165											D: Deserializer<'de>,
5166										{
5167											Ok(DeserializeWith(serde_with::As::<
5168												serde_with::OneOrMany<serde_with::Same>,
5169											>::deserialize(deserializer)?))
5170										}
5171									}
5172									match map.next_value::<DeserializeWith>() {
5173										Ok(deserialize_with) => deserialize_with.0,
5174										Err(err) => {
5175											return Err(err);
5176										}
5177									}
5178								});
5179							}
5180							Field::AlternativeHeadline => {
5181								if r#alternative_headline_property.is_some() {
5182									return Err(<A::Error as de::Error>::duplicate_field(
5183										"alternativeHeadline",
5184									));
5185								}
5186								r#alternative_headline_property = Some({
5187									struct DeserializeWith(Vec<AlternativeHeadlineProperty>);
5188									impl<'de> Deserialize<'de> for DeserializeWith {
5189										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5190										where
5191											D: Deserializer<'de>,
5192										{
5193											Ok(DeserializeWith(serde_with::As::<
5194												serde_with::OneOrMany<serde_with::Same>,
5195											>::deserialize(deserializer)?))
5196										}
5197									}
5198									match map.next_value::<DeserializeWith>() {
5199										Ok(deserialize_with) => deserialize_with.0,
5200										Err(err) => {
5201											return Err(err);
5202										}
5203									}
5204								});
5205							}
5206							Field::ArchivedAt => {
5207								if r#archived_at_property.is_some() {
5208									return Err(<A::Error as de::Error>::duplicate_field(
5209										"archivedAt",
5210									));
5211								}
5212								r#archived_at_property = Some({
5213									struct DeserializeWith(Vec<ArchivedAtProperty>);
5214									impl<'de> Deserialize<'de> for DeserializeWith {
5215										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5216										where
5217											D: Deserializer<'de>,
5218										{
5219											Ok(DeserializeWith(serde_with::As::<
5220												serde_with::OneOrMany<serde_with::Same>,
5221											>::deserialize(deserializer)?))
5222										}
5223									}
5224									match map.next_value::<DeserializeWith>() {
5225										Ok(deserialize_with) => deserialize_with.0,
5226										Err(err) => {
5227											return Err(err);
5228										}
5229									}
5230								});
5231							}
5232							Field::Assesses => {
5233								if r#assesses_property.is_some() {
5234									return Err(<A::Error as de::Error>::duplicate_field(
5235										"assesses",
5236									));
5237								}
5238								r#assesses_property = Some({
5239									struct DeserializeWith(Vec<AssessesProperty>);
5240									impl<'de> Deserialize<'de> for DeserializeWith {
5241										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5242										where
5243											D: Deserializer<'de>,
5244										{
5245											Ok(DeserializeWith(serde_with::As::<
5246												serde_with::OneOrMany<serde_with::Same>,
5247											>::deserialize(deserializer)?))
5248										}
5249									}
5250									match map.next_value::<DeserializeWith>() {
5251										Ok(deserialize_with) => deserialize_with.0,
5252										Err(err) => {
5253											return Err(err);
5254										}
5255									}
5256								});
5257							}
5258							Field::AssociatedMedia => {
5259								if r#associated_media_property.is_some() {
5260									return Err(<A::Error as de::Error>::duplicate_field(
5261										"associatedMedia",
5262									));
5263								}
5264								r#associated_media_property = Some({
5265									struct DeserializeWith(Vec<AssociatedMediaProperty>);
5266									impl<'de> Deserialize<'de> for DeserializeWith {
5267										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5268										where
5269											D: Deserializer<'de>,
5270										{
5271											Ok(DeserializeWith(serde_with::As::<
5272												serde_with::OneOrMany<serde_with::Same>,
5273											>::deserialize(deserializer)?))
5274										}
5275									}
5276									match map.next_value::<DeserializeWith>() {
5277										Ok(deserialize_with) => deserialize_with.0,
5278										Err(err) => {
5279											return Err(err);
5280										}
5281									}
5282								});
5283							}
5284							Field::Audience => {
5285								if r#audience_property.is_some() {
5286									return Err(<A::Error as de::Error>::duplicate_field(
5287										"audience",
5288									));
5289								}
5290								r#audience_property = Some({
5291									struct DeserializeWith(Vec<AudienceProperty>);
5292									impl<'de> Deserialize<'de> for DeserializeWith {
5293										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5294										where
5295											D: Deserializer<'de>,
5296										{
5297											Ok(DeserializeWith(serde_with::As::<
5298												serde_with::OneOrMany<serde_with::Same>,
5299											>::deserialize(deserializer)?))
5300										}
5301									}
5302									match map.next_value::<DeserializeWith>() {
5303										Ok(deserialize_with) => deserialize_with.0,
5304										Err(err) => {
5305											return Err(err);
5306										}
5307									}
5308								});
5309							}
5310							Field::Audio => {
5311								if r#audio_property.is_some() {
5312									return Err(<A::Error as de::Error>::duplicate_field("audio"));
5313								}
5314								r#audio_property = Some({
5315									struct DeserializeWith(Vec<AudioProperty>);
5316									impl<'de> Deserialize<'de> for DeserializeWith {
5317										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5318										where
5319											D: Deserializer<'de>,
5320										{
5321											Ok(DeserializeWith(serde_with::As::<
5322												serde_with::OneOrMany<serde_with::Same>,
5323											>::deserialize(deserializer)?))
5324										}
5325									}
5326									match map.next_value::<DeserializeWith>() {
5327										Ok(deserialize_with) => deserialize_with.0,
5328										Err(err) => {
5329											return Err(err);
5330										}
5331									}
5332								});
5333							}
5334							Field::Author => {
5335								if r#author_property.is_some() {
5336									return Err(<A::Error as de::Error>::duplicate_field("author"));
5337								}
5338								r#author_property = Some({
5339									struct DeserializeWith(Vec<AuthorProperty>);
5340									impl<'de> Deserialize<'de> for DeserializeWith {
5341										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5342										where
5343											D: Deserializer<'de>,
5344										{
5345											Ok(DeserializeWith(serde_with::As::<
5346												serde_with::OneOrMany<serde_with::Same>,
5347											>::deserialize(deserializer)?))
5348										}
5349									}
5350									match map.next_value::<DeserializeWith>() {
5351										Ok(deserialize_with) => deserialize_with.0,
5352										Err(err) => {
5353											return Err(err);
5354										}
5355									}
5356								});
5357							}
5358							Field::Award => {
5359								if r#award_property.is_some() {
5360									return Err(<A::Error as de::Error>::duplicate_field("award"));
5361								}
5362								r#award_property = Some({
5363									struct DeserializeWith(Vec<AwardProperty>);
5364									impl<'de> Deserialize<'de> for DeserializeWith {
5365										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5366										where
5367											D: Deserializer<'de>,
5368										{
5369											Ok(DeserializeWith(serde_with::As::<
5370												serde_with::OneOrMany<serde_with::Same>,
5371											>::deserialize(deserializer)?))
5372										}
5373									}
5374									match map.next_value::<DeserializeWith>() {
5375										Ok(deserialize_with) => deserialize_with.0,
5376										Err(err) => {
5377											return Err(err);
5378										}
5379									}
5380								});
5381							}
5382							Field::Awards => {
5383								if r#awards_property.is_some() {
5384									return Err(<A::Error as de::Error>::duplicate_field("awards"));
5385								}
5386								r#awards_property = Some({
5387									struct DeserializeWith(Vec<AwardsProperty>);
5388									impl<'de> Deserialize<'de> for DeserializeWith {
5389										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5390										where
5391											D: Deserializer<'de>,
5392										{
5393											Ok(DeserializeWith(serde_with::As::<
5394												serde_with::OneOrMany<serde_with::Same>,
5395											>::deserialize(deserializer)?))
5396										}
5397									}
5398									match map.next_value::<DeserializeWith>() {
5399										Ok(deserialize_with) => deserialize_with.0,
5400										Err(err) => {
5401											return Err(err);
5402										}
5403									}
5404								});
5405							}
5406							Field::Character => {
5407								if r#character_property.is_some() {
5408									return Err(<A::Error as de::Error>::duplicate_field(
5409										"character",
5410									));
5411								}
5412								r#character_property = Some({
5413									struct DeserializeWith(Vec<CharacterProperty>);
5414									impl<'de> Deserialize<'de> for DeserializeWith {
5415										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5416										where
5417											D: Deserializer<'de>,
5418										{
5419											Ok(DeserializeWith(serde_with::As::<
5420												serde_with::OneOrMany<serde_with::Same>,
5421											>::deserialize(deserializer)?))
5422										}
5423									}
5424									match map.next_value::<DeserializeWith>() {
5425										Ok(deserialize_with) => deserialize_with.0,
5426										Err(err) => {
5427											return Err(err);
5428										}
5429									}
5430								});
5431							}
5432							Field::Citation => {
5433								if r#citation_property.is_some() {
5434									return Err(<A::Error as de::Error>::duplicate_field(
5435										"citation",
5436									));
5437								}
5438								r#citation_property = Some({
5439									struct DeserializeWith(Vec<CitationProperty>);
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::Comment => {
5459								if r#comment_property.is_some() {
5460									return Err(<A::Error as de::Error>::duplicate_field(
5461										"comment",
5462									));
5463								}
5464								r#comment_property = Some({
5465									struct DeserializeWith(Vec<CommentProperty>);
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::CommentCount => {
5485								if r#comment_count_property.is_some() {
5486									return Err(<A::Error as de::Error>::duplicate_field(
5487										"commentCount",
5488									));
5489								}
5490								r#comment_count_property = Some({
5491									struct DeserializeWith(Vec<CommentCountProperty>);
5492									impl<'de> Deserialize<'de> for DeserializeWith {
5493										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5494										where
5495											D: Deserializer<'de>,
5496										{
5497											Ok(DeserializeWith(serde_with::As::<
5498												serde_with::OneOrMany<serde_with::Same>,
5499											>::deserialize(deserializer)?))
5500										}
5501									}
5502									match map.next_value::<DeserializeWith>() {
5503										Ok(deserialize_with) => deserialize_with.0,
5504										Err(err) => {
5505											return Err(err);
5506										}
5507									}
5508								});
5509							}
5510							Field::ConditionsOfAccess => {
5511								if r#conditions_of_access_property.is_some() {
5512									return Err(<A::Error as de::Error>::duplicate_field(
5513										"conditionsOfAccess",
5514									));
5515								}
5516								r#conditions_of_access_property = Some({
5517									struct DeserializeWith(Vec<ConditionsOfAccessProperty>);
5518									impl<'de> Deserialize<'de> for DeserializeWith {
5519										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5520										where
5521											D: Deserializer<'de>,
5522										{
5523											Ok(DeserializeWith(serde_with::As::<
5524												serde_with::OneOrMany<serde_with::Same>,
5525											>::deserialize(deserializer)?))
5526										}
5527									}
5528									match map.next_value::<DeserializeWith>() {
5529										Ok(deserialize_with) => deserialize_with.0,
5530										Err(err) => {
5531											return Err(err);
5532										}
5533									}
5534								});
5535							}
5536							Field::ContentLocation => {
5537								if r#content_location_property.is_some() {
5538									return Err(<A::Error as de::Error>::duplicate_field(
5539										"contentLocation",
5540									));
5541								}
5542								r#content_location_property = Some({
5543									struct DeserializeWith(Vec<ContentLocationProperty>);
5544									impl<'de> Deserialize<'de> for DeserializeWith {
5545										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5546										where
5547											D: Deserializer<'de>,
5548										{
5549											Ok(DeserializeWith(serde_with::As::<
5550												serde_with::OneOrMany<serde_with::Same>,
5551											>::deserialize(deserializer)?))
5552										}
5553									}
5554									match map.next_value::<DeserializeWith>() {
5555										Ok(deserialize_with) => deserialize_with.0,
5556										Err(err) => {
5557											return Err(err);
5558										}
5559									}
5560								});
5561							}
5562							Field::ContentRating => {
5563								if r#content_rating_property.is_some() {
5564									return Err(<A::Error as de::Error>::duplicate_field(
5565										"contentRating",
5566									));
5567								}
5568								r#content_rating_property = Some({
5569									struct DeserializeWith(Vec<ContentRatingProperty>);
5570									impl<'de> Deserialize<'de> for DeserializeWith {
5571										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5572										where
5573											D: Deserializer<'de>,
5574										{
5575											Ok(DeserializeWith(serde_with::As::<
5576												serde_with::OneOrMany<serde_with::Same>,
5577											>::deserialize(deserializer)?))
5578										}
5579									}
5580									match map.next_value::<DeserializeWith>() {
5581										Ok(deserialize_with) => deserialize_with.0,
5582										Err(err) => {
5583											return Err(err);
5584										}
5585									}
5586								});
5587							}
5588							Field::ContentReferenceTime => {
5589								if r#content_reference_time_property.is_some() {
5590									return Err(<A::Error as de::Error>::duplicate_field(
5591										"contentReferenceTime",
5592									));
5593								}
5594								r#content_reference_time_property = Some({
5595									struct DeserializeWith(Vec<ContentReferenceTimeProperty>);
5596									impl<'de> Deserialize<'de> for DeserializeWith {
5597										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5598										where
5599											D: Deserializer<'de>,
5600										{
5601											Ok(DeserializeWith(serde_with::As::<
5602												serde_with::OneOrMany<serde_with::Same>,
5603											>::deserialize(deserializer)?))
5604										}
5605									}
5606									match map.next_value::<DeserializeWith>() {
5607										Ok(deserialize_with) => deserialize_with.0,
5608										Err(err) => {
5609											return Err(err);
5610										}
5611									}
5612								});
5613							}
5614							Field::Contributor => {
5615								if r#contributor_property.is_some() {
5616									return Err(<A::Error as de::Error>::duplicate_field(
5617										"contributor",
5618									));
5619								}
5620								r#contributor_property = Some({
5621									struct DeserializeWith(Vec<ContributorProperty>);
5622									impl<'de> Deserialize<'de> for DeserializeWith {
5623										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5624										where
5625											D: Deserializer<'de>,
5626										{
5627											Ok(DeserializeWith(serde_with::As::<
5628												serde_with::OneOrMany<serde_with::Same>,
5629											>::deserialize(deserializer)?))
5630										}
5631									}
5632									match map.next_value::<DeserializeWith>() {
5633										Ok(deserialize_with) => deserialize_with.0,
5634										Err(err) => {
5635											return Err(err);
5636										}
5637									}
5638								});
5639							}
5640							Field::CopyrightHolder => {
5641								if r#copyright_holder_property.is_some() {
5642									return Err(<A::Error as de::Error>::duplicate_field(
5643										"copyrightHolder",
5644									));
5645								}
5646								r#copyright_holder_property = Some({
5647									struct DeserializeWith(Vec<CopyrightHolderProperty>);
5648									impl<'de> Deserialize<'de> for DeserializeWith {
5649										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5650										where
5651											D: Deserializer<'de>,
5652										{
5653											Ok(DeserializeWith(serde_with::As::<
5654												serde_with::OneOrMany<serde_with::Same>,
5655											>::deserialize(deserializer)?))
5656										}
5657									}
5658									match map.next_value::<DeserializeWith>() {
5659										Ok(deserialize_with) => deserialize_with.0,
5660										Err(err) => {
5661											return Err(err);
5662										}
5663									}
5664								});
5665							}
5666							Field::CopyrightNotice => {
5667								if r#copyright_notice_property.is_some() {
5668									return Err(<A::Error as de::Error>::duplicate_field(
5669										"copyrightNotice",
5670									));
5671								}
5672								r#copyright_notice_property = Some({
5673									struct DeserializeWith(Vec<CopyrightNoticeProperty>);
5674									impl<'de> Deserialize<'de> for DeserializeWith {
5675										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5676										where
5677											D: Deserializer<'de>,
5678										{
5679											Ok(DeserializeWith(serde_with::As::<
5680												serde_with::OneOrMany<serde_with::Same>,
5681											>::deserialize(deserializer)?))
5682										}
5683									}
5684									match map.next_value::<DeserializeWith>() {
5685										Ok(deserialize_with) => deserialize_with.0,
5686										Err(err) => {
5687											return Err(err);
5688										}
5689									}
5690								});
5691							}
5692							Field::CopyrightYear => {
5693								if r#copyright_year_property.is_some() {
5694									return Err(<A::Error as de::Error>::duplicate_field(
5695										"copyrightYear",
5696									));
5697								}
5698								r#copyright_year_property = Some({
5699									struct DeserializeWith(Vec<CopyrightYearProperty>);
5700									impl<'de> Deserialize<'de> for DeserializeWith {
5701										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5702										where
5703											D: Deserializer<'de>,
5704										{
5705											Ok(DeserializeWith(serde_with::As::<
5706												serde_with::OneOrMany<serde_with::Same>,
5707											>::deserialize(deserializer)?))
5708										}
5709									}
5710									match map.next_value::<DeserializeWith>() {
5711										Ok(deserialize_with) => deserialize_with.0,
5712										Err(err) => {
5713											return Err(err);
5714										}
5715									}
5716								});
5717							}
5718							Field::Correction => {
5719								if r#correction_property.is_some() {
5720									return Err(<A::Error as de::Error>::duplicate_field(
5721										"correction",
5722									));
5723								}
5724								r#correction_property = Some({
5725									struct DeserializeWith(Vec<CorrectionProperty>);
5726									impl<'de> Deserialize<'de> for DeserializeWith {
5727										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5728										where
5729											D: Deserializer<'de>,
5730										{
5731											Ok(DeserializeWith(serde_with::As::<
5732												serde_with::OneOrMany<serde_with::Same>,
5733											>::deserialize(deserializer)?))
5734										}
5735									}
5736									match map.next_value::<DeserializeWith>() {
5737										Ok(deserialize_with) => deserialize_with.0,
5738										Err(err) => {
5739											return Err(err);
5740										}
5741									}
5742								});
5743							}
5744							Field::CountryOfOrigin => {
5745								if r#country_of_origin_property.is_some() {
5746									return Err(<A::Error as de::Error>::duplicate_field(
5747										"countryOfOrigin",
5748									));
5749								}
5750								r#country_of_origin_property = Some({
5751									struct DeserializeWith(Vec<CountryOfOriginProperty>);
5752									impl<'de> Deserialize<'de> for DeserializeWith {
5753										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5754										where
5755											D: Deserializer<'de>,
5756										{
5757											Ok(DeserializeWith(serde_with::As::<
5758												serde_with::OneOrMany<serde_with::Same>,
5759											>::deserialize(deserializer)?))
5760										}
5761									}
5762									match map.next_value::<DeserializeWith>() {
5763										Ok(deserialize_with) => deserialize_with.0,
5764										Err(err) => {
5765											return Err(err);
5766										}
5767									}
5768								});
5769							}
5770							Field::CreativeWorkStatus => {
5771								if r#creative_work_status_property.is_some() {
5772									return Err(<A::Error as de::Error>::duplicate_field(
5773										"creativeWorkStatus",
5774									));
5775								}
5776								r#creative_work_status_property = Some({
5777									struct DeserializeWith(Vec<CreativeWorkStatusProperty>);
5778									impl<'de> Deserialize<'de> for DeserializeWith {
5779										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5780										where
5781											D: Deserializer<'de>,
5782										{
5783											Ok(DeserializeWith(serde_with::As::<
5784												serde_with::OneOrMany<serde_with::Same>,
5785											>::deserialize(deserializer)?))
5786										}
5787									}
5788									match map.next_value::<DeserializeWith>() {
5789										Ok(deserialize_with) => deserialize_with.0,
5790										Err(err) => {
5791											return Err(err);
5792										}
5793									}
5794								});
5795							}
5796							Field::Creator => {
5797								if r#creator_property.is_some() {
5798									return Err(<A::Error as de::Error>::duplicate_field(
5799										"creator",
5800									));
5801								}
5802								r#creator_property = Some({
5803									struct DeserializeWith(Vec<CreatorProperty>);
5804									impl<'de> Deserialize<'de> for DeserializeWith {
5805										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5806										where
5807											D: Deserializer<'de>,
5808										{
5809											Ok(DeserializeWith(serde_with::As::<
5810												serde_with::OneOrMany<serde_with::Same>,
5811											>::deserialize(deserializer)?))
5812										}
5813									}
5814									match map.next_value::<DeserializeWith>() {
5815										Ok(deserialize_with) => deserialize_with.0,
5816										Err(err) => {
5817											return Err(err);
5818										}
5819									}
5820								});
5821							}
5822							Field::CreditText => {
5823								if r#credit_text_property.is_some() {
5824									return Err(<A::Error as de::Error>::duplicate_field(
5825										"creditText",
5826									));
5827								}
5828								r#credit_text_property = Some({
5829									struct DeserializeWith(Vec<CreditTextProperty>);
5830									impl<'de> Deserialize<'de> for DeserializeWith {
5831										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5832										where
5833											D: Deserializer<'de>,
5834										{
5835											Ok(DeserializeWith(serde_with::As::<
5836												serde_with::OneOrMany<serde_with::Same>,
5837											>::deserialize(deserializer)?))
5838										}
5839									}
5840									match map.next_value::<DeserializeWith>() {
5841										Ok(deserialize_with) => deserialize_with.0,
5842										Err(err) => {
5843											return Err(err);
5844										}
5845									}
5846								});
5847							}
5848							Field::DateCreated => {
5849								if r#date_created_property.is_some() {
5850									return Err(<A::Error as de::Error>::duplicate_field(
5851										"dateCreated",
5852									));
5853								}
5854								r#date_created_property = Some({
5855									struct DeserializeWith(Vec<DateCreatedProperty>);
5856									impl<'de> Deserialize<'de> for DeserializeWith {
5857										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5858										where
5859											D: Deserializer<'de>,
5860										{
5861											Ok(DeserializeWith(serde_with::As::<
5862												serde_with::OneOrMany<serde_with::Same>,
5863											>::deserialize(deserializer)?))
5864										}
5865									}
5866									match map.next_value::<DeserializeWith>() {
5867										Ok(deserialize_with) => deserialize_with.0,
5868										Err(err) => {
5869											return Err(err);
5870										}
5871									}
5872								});
5873							}
5874							Field::DateModified => {
5875								if r#date_modified_property.is_some() {
5876									return Err(<A::Error as de::Error>::duplicate_field(
5877										"dateModified",
5878									));
5879								}
5880								r#date_modified_property = Some({
5881									struct DeserializeWith(Vec<DateModifiedProperty>);
5882									impl<'de> Deserialize<'de> for DeserializeWith {
5883										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5884										where
5885											D: Deserializer<'de>,
5886										{
5887											Ok(DeserializeWith(serde_with::As::<
5888												serde_with::OneOrMany<serde_with::Same>,
5889											>::deserialize(deserializer)?))
5890										}
5891									}
5892									match map.next_value::<DeserializeWith>() {
5893										Ok(deserialize_with) => deserialize_with.0,
5894										Err(err) => {
5895											return Err(err);
5896										}
5897									}
5898								});
5899							}
5900							Field::DatePublished => {
5901								if r#date_published_property.is_some() {
5902									return Err(<A::Error as de::Error>::duplicate_field(
5903										"datePublished",
5904									));
5905								}
5906								r#date_published_property = Some({
5907									struct DeserializeWith(Vec<DatePublishedProperty>);
5908									impl<'de> Deserialize<'de> for DeserializeWith {
5909										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5910										where
5911											D: Deserializer<'de>,
5912										{
5913											Ok(DeserializeWith(serde_with::As::<
5914												serde_with::OneOrMany<serde_with::Same>,
5915											>::deserialize(deserializer)?))
5916										}
5917									}
5918									match map.next_value::<DeserializeWith>() {
5919										Ok(deserialize_with) => deserialize_with.0,
5920										Err(err) => {
5921											return Err(err);
5922										}
5923									}
5924								});
5925							}
5926							Field::DiscussionUrl => {
5927								if r#discussion_url_property.is_some() {
5928									return Err(<A::Error as de::Error>::duplicate_field(
5929										"discussionUrl",
5930									));
5931								}
5932								r#discussion_url_property = Some({
5933									struct DeserializeWith(Vec<DiscussionUrlProperty>);
5934									impl<'de> Deserialize<'de> for DeserializeWith {
5935										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5936										where
5937											D: Deserializer<'de>,
5938										{
5939											Ok(DeserializeWith(serde_with::As::<
5940												serde_with::OneOrMany<serde_with::Same>,
5941											>::deserialize(deserializer)?))
5942										}
5943									}
5944									match map.next_value::<DeserializeWith>() {
5945										Ok(deserialize_with) => deserialize_with.0,
5946										Err(err) => {
5947											return Err(err);
5948										}
5949									}
5950								});
5951							}
5952							Field::EditEidr => {
5953								if r#edit_eidr_property.is_some() {
5954									return Err(<A::Error as de::Error>::duplicate_field(
5955										"editEIDR",
5956									));
5957								}
5958								r#edit_eidr_property = Some({
5959									struct DeserializeWith(Vec<EditEidrProperty>);
5960									impl<'de> Deserialize<'de> for DeserializeWith {
5961										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5962										where
5963											D: Deserializer<'de>,
5964										{
5965											Ok(DeserializeWith(serde_with::As::<
5966												serde_with::OneOrMany<serde_with::Same>,
5967											>::deserialize(deserializer)?))
5968										}
5969									}
5970									match map.next_value::<DeserializeWith>() {
5971										Ok(deserialize_with) => deserialize_with.0,
5972										Err(err) => {
5973											return Err(err);
5974										}
5975									}
5976								});
5977							}
5978							Field::Editor => {
5979								if r#editor_property.is_some() {
5980									return Err(<A::Error as de::Error>::duplicate_field("editor"));
5981								}
5982								r#editor_property = Some({
5983									struct DeserializeWith(Vec<EditorProperty>);
5984									impl<'de> Deserialize<'de> for DeserializeWith {
5985										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5986										where
5987											D: Deserializer<'de>,
5988										{
5989											Ok(DeserializeWith(serde_with::As::<
5990												serde_with::OneOrMany<serde_with::Same>,
5991											>::deserialize(deserializer)?))
5992										}
5993									}
5994									match map.next_value::<DeserializeWith>() {
5995										Ok(deserialize_with) => deserialize_with.0,
5996										Err(err) => {
5997											return Err(err);
5998										}
5999									}
6000								});
6001							}
6002							Field::EducationalAlignment => {
6003								if r#educational_alignment_property.is_some() {
6004									return Err(<A::Error as de::Error>::duplicate_field(
6005										"educationalAlignment",
6006									));
6007								}
6008								r#educational_alignment_property = Some({
6009									struct DeserializeWith(Vec<EducationalAlignmentProperty>);
6010									impl<'de> Deserialize<'de> for DeserializeWith {
6011										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6012										where
6013											D: Deserializer<'de>,
6014										{
6015											Ok(DeserializeWith(serde_with::As::<
6016												serde_with::OneOrMany<serde_with::Same>,
6017											>::deserialize(deserializer)?))
6018										}
6019									}
6020									match map.next_value::<DeserializeWith>() {
6021										Ok(deserialize_with) => deserialize_with.0,
6022										Err(err) => {
6023											return Err(err);
6024										}
6025									}
6026								});
6027							}
6028							Field::EducationalLevel => {
6029								if r#educational_level_property.is_some() {
6030									return Err(<A::Error as de::Error>::duplicate_field(
6031										"educationalLevel",
6032									));
6033								}
6034								r#educational_level_property = Some({
6035									struct DeserializeWith(Vec<EducationalLevelProperty>);
6036									impl<'de> Deserialize<'de> for DeserializeWith {
6037										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6038										where
6039											D: Deserializer<'de>,
6040										{
6041											Ok(DeserializeWith(serde_with::As::<
6042												serde_with::OneOrMany<serde_with::Same>,
6043											>::deserialize(deserializer)?))
6044										}
6045									}
6046									match map.next_value::<DeserializeWith>() {
6047										Ok(deserialize_with) => deserialize_with.0,
6048										Err(err) => {
6049											return Err(err);
6050										}
6051									}
6052								});
6053							}
6054							Field::EducationalUse => {
6055								if r#educational_use_property.is_some() {
6056									return Err(<A::Error as de::Error>::duplicate_field(
6057										"educationalUse",
6058									));
6059								}
6060								r#educational_use_property = Some({
6061									struct DeserializeWith(Vec<EducationalUseProperty>);
6062									impl<'de> Deserialize<'de> for DeserializeWith {
6063										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6064										where
6065											D: Deserializer<'de>,
6066										{
6067											Ok(DeserializeWith(serde_with::As::<
6068												serde_with::OneOrMany<serde_with::Same>,
6069											>::deserialize(deserializer)?))
6070										}
6071									}
6072									match map.next_value::<DeserializeWith>() {
6073										Ok(deserialize_with) => deserialize_with.0,
6074										Err(err) => {
6075											return Err(err);
6076										}
6077									}
6078								});
6079							}
6080							Field::Encoding => {
6081								if r#encoding_property.is_some() {
6082									return Err(<A::Error as de::Error>::duplicate_field(
6083										"encoding",
6084									));
6085								}
6086								r#encoding_property = Some({
6087									struct DeserializeWith(Vec<EncodingProperty>);
6088									impl<'de> Deserialize<'de> for DeserializeWith {
6089										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6090										where
6091											D: Deserializer<'de>,
6092										{
6093											Ok(DeserializeWith(serde_with::As::<
6094												serde_with::OneOrMany<serde_with::Same>,
6095											>::deserialize(deserializer)?))
6096										}
6097									}
6098									match map.next_value::<DeserializeWith>() {
6099										Ok(deserialize_with) => deserialize_with.0,
6100										Err(err) => {
6101											return Err(err);
6102										}
6103									}
6104								});
6105							}
6106							Field::EncodingFormat => {
6107								if r#encoding_format_property.is_some() {
6108									return Err(<A::Error as de::Error>::duplicate_field(
6109										"encodingFormat",
6110									));
6111								}
6112								r#encoding_format_property = Some({
6113									struct DeserializeWith(Vec<EncodingFormatProperty>);
6114									impl<'de> Deserialize<'de> for DeserializeWith {
6115										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6116										where
6117											D: Deserializer<'de>,
6118										{
6119											Ok(DeserializeWith(serde_with::As::<
6120												serde_with::OneOrMany<serde_with::Same>,
6121											>::deserialize(deserializer)?))
6122										}
6123									}
6124									match map.next_value::<DeserializeWith>() {
6125										Ok(deserialize_with) => deserialize_with.0,
6126										Err(err) => {
6127											return Err(err);
6128										}
6129									}
6130								});
6131							}
6132							Field::Encodings => {
6133								if r#encodings_property.is_some() {
6134									return Err(<A::Error as de::Error>::duplicate_field(
6135										"encodings",
6136									));
6137								}
6138								r#encodings_property = Some({
6139									struct DeserializeWith(Vec<EncodingsProperty>);
6140									impl<'de> Deserialize<'de> for DeserializeWith {
6141										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6142										where
6143											D: Deserializer<'de>,
6144										{
6145											Ok(DeserializeWith(serde_with::As::<
6146												serde_with::OneOrMany<serde_with::Same>,
6147											>::deserialize(deserializer)?))
6148										}
6149									}
6150									match map.next_value::<DeserializeWith>() {
6151										Ok(deserialize_with) => deserialize_with.0,
6152										Err(err) => {
6153											return Err(err);
6154										}
6155									}
6156								});
6157							}
6158							Field::ExampleOfWork => {
6159								if r#example_of_work_property.is_some() {
6160									return Err(<A::Error as de::Error>::duplicate_field(
6161										"exampleOfWork",
6162									));
6163								}
6164								r#example_of_work_property = Some({
6165									struct DeserializeWith(Vec<ExampleOfWorkProperty>);
6166									impl<'de> Deserialize<'de> for DeserializeWith {
6167										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6168										where
6169											D: Deserializer<'de>,
6170										{
6171											Ok(DeserializeWith(serde_with::As::<
6172												serde_with::OneOrMany<serde_with::Same>,
6173											>::deserialize(deserializer)?))
6174										}
6175									}
6176									match map.next_value::<DeserializeWith>() {
6177										Ok(deserialize_with) => deserialize_with.0,
6178										Err(err) => {
6179											return Err(err);
6180										}
6181									}
6182								});
6183							}
6184							Field::Expires => {
6185								if r#expires_property.is_some() {
6186									return Err(<A::Error as de::Error>::duplicate_field(
6187										"expires",
6188									));
6189								}
6190								r#expires_property = Some({
6191									struct DeserializeWith(Vec<ExpiresProperty>);
6192									impl<'de> Deserialize<'de> for DeserializeWith {
6193										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6194										where
6195											D: Deserializer<'de>,
6196										{
6197											Ok(DeserializeWith(serde_with::As::<
6198												serde_with::OneOrMany<serde_with::Same>,
6199											>::deserialize(deserializer)?))
6200										}
6201									}
6202									match map.next_value::<DeserializeWith>() {
6203										Ok(deserialize_with) => deserialize_with.0,
6204										Err(err) => {
6205											return Err(err);
6206										}
6207									}
6208								});
6209							}
6210							Field::FileFormat => {
6211								if r#file_format_property.is_some() {
6212									return Err(<A::Error as de::Error>::duplicate_field(
6213										"fileFormat",
6214									));
6215								}
6216								r#file_format_property = Some({
6217									struct DeserializeWith(Vec<FileFormatProperty>);
6218									impl<'de> Deserialize<'de> for DeserializeWith {
6219										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6220										where
6221											D: Deserializer<'de>,
6222										{
6223											Ok(DeserializeWith(serde_with::As::<
6224												serde_with::OneOrMany<serde_with::Same>,
6225											>::deserialize(deserializer)?))
6226										}
6227									}
6228									match map.next_value::<DeserializeWith>() {
6229										Ok(deserialize_with) => deserialize_with.0,
6230										Err(err) => {
6231											return Err(err);
6232										}
6233									}
6234								});
6235							}
6236							Field::Funder => {
6237								if r#funder_property.is_some() {
6238									return Err(<A::Error as de::Error>::duplicate_field("funder"));
6239								}
6240								r#funder_property = Some({
6241									struct DeserializeWith(Vec<FunderProperty>);
6242									impl<'de> Deserialize<'de> for DeserializeWith {
6243										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6244										where
6245											D: Deserializer<'de>,
6246										{
6247											Ok(DeserializeWith(serde_with::As::<
6248												serde_with::OneOrMany<serde_with::Same>,
6249											>::deserialize(deserializer)?))
6250										}
6251									}
6252									match map.next_value::<DeserializeWith>() {
6253										Ok(deserialize_with) => deserialize_with.0,
6254										Err(err) => {
6255											return Err(err);
6256										}
6257									}
6258								});
6259							}
6260							Field::Funding => {
6261								if r#funding_property.is_some() {
6262									return Err(<A::Error as de::Error>::duplicate_field(
6263										"funding",
6264									));
6265								}
6266								r#funding_property = Some({
6267									struct DeserializeWith(Vec<FundingProperty>);
6268									impl<'de> Deserialize<'de> for DeserializeWith {
6269										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6270										where
6271											D: Deserializer<'de>,
6272										{
6273											Ok(DeserializeWith(serde_with::As::<
6274												serde_with::OneOrMany<serde_with::Same>,
6275											>::deserialize(deserializer)?))
6276										}
6277									}
6278									match map.next_value::<DeserializeWith>() {
6279										Ok(deserialize_with) => deserialize_with.0,
6280										Err(err) => {
6281											return Err(err);
6282										}
6283									}
6284								});
6285							}
6286							Field::Genre => {
6287								if r#genre_property.is_some() {
6288									return Err(<A::Error as de::Error>::duplicate_field("genre"));
6289								}
6290								r#genre_property = Some({
6291									struct DeserializeWith(Vec<GenreProperty>);
6292									impl<'de> Deserialize<'de> for DeserializeWith {
6293										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6294										where
6295											D: Deserializer<'de>,
6296										{
6297											Ok(DeserializeWith(serde_with::As::<
6298												serde_with::OneOrMany<serde_with::Same>,
6299											>::deserialize(deserializer)?))
6300										}
6301									}
6302									match map.next_value::<DeserializeWith>() {
6303										Ok(deserialize_with) => deserialize_with.0,
6304										Err(err) => {
6305											return Err(err);
6306										}
6307									}
6308								});
6309							}
6310							Field::HasPart => {
6311								if r#has_part_property.is_some() {
6312									return Err(<A::Error as de::Error>::duplicate_field(
6313										"hasPart",
6314									));
6315								}
6316								r#has_part_property = Some({
6317									struct DeserializeWith(Vec<HasPartProperty>);
6318									impl<'de> Deserialize<'de> for DeserializeWith {
6319										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6320										where
6321											D: Deserializer<'de>,
6322										{
6323											Ok(DeserializeWith(serde_with::As::<
6324												serde_with::OneOrMany<serde_with::Same>,
6325											>::deserialize(deserializer)?))
6326										}
6327									}
6328									match map.next_value::<DeserializeWith>() {
6329										Ok(deserialize_with) => deserialize_with.0,
6330										Err(err) => {
6331											return Err(err);
6332										}
6333									}
6334								});
6335							}
6336							Field::Headline => {
6337								if r#headline_property.is_some() {
6338									return Err(<A::Error as de::Error>::duplicate_field(
6339										"headline",
6340									));
6341								}
6342								r#headline_property = Some({
6343									struct DeserializeWith(Vec<HeadlineProperty>);
6344									impl<'de> Deserialize<'de> for DeserializeWith {
6345										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6346										where
6347											D: Deserializer<'de>,
6348										{
6349											Ok(DeserializeWith(serde_with::As::<
6350												serde_with::OneOrMany<serde_with::Same>,
6351											>::deserialize(deserializer)?))
6352										}
6353									}
6354									match map.next_value::<DeserializeWith>() {
6355										Ok(deserialize_with) => deserialize_with.0,
6356										Err(err) => {
6357											return Err(err);
6358										}
6359									}
6360								});
6361							}
6362							Field::InLanguage => {
6363								if r#in_language_property.is_some() {
6364									return Err(<A::Error as de::Error>::duplicate_field(
6365										"inLanguage",
6366									));
6367								}
6368								r#in_language_property = Some({
6369									struct DeserializeWith(Vec<InLanguageProperty>);
6370									impl<'de> Deserialize<'de> for DeserializeWith {
6371										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6372										where
6373											D: Deserializer<'de>,
6374										{
6375											Ok(DeserializeWith(serde_with::As::<
6376												serde_with::OneOrMany<serde_with::Same>,
6377											>::deserialize(deserializer)?))
6378										}
6379									}
6380									match map.next_value::<DeserializeWith>() {
6381										Ok(deserialize_with) => deserialize_with.0,
6382										Err(err) => {
6383											return Err(err);
6384										}
6385									}
6386								});
6387							}
6388							Field::InteractionStatistic => {
6389								if r#interaction_statistic_property.is_some() {
6390									return Err(<A::Error as de::Error>::duplicate_field(
6391										"interactionStatistic",
6392									));
6393								}
6394								r#interaction_statistic_property = Some({
6395									struct DeserializeWith(Vec<InteractionStatisticProperty>);
6396									impl<'de> Deserialize<'de> for DeserializeWith {
6397										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6398										where
6399											D: Deserializer<'de>,
6400										{
6401											Ok(DeserializeWith(serde_with::As::<
6402												serde_with::OneOrMany<serde_with::Same>,
6403											>::deserialize(deserializer)?))
6404										}
6405									}
6406									match map.next_value::<DeserializeWith>() {
6407										Ok(deserialize_with) => deserialize_with.0,
6408										Err(err) => {
6409											return Err(err);
6410										}
6411									}
6412								});
6413							}
6414							Field::InteractivityType => {
6415								if r#interactivity_type_property.is_some() {
6416									return Err(<A::Error as de::Error>::duplicate_field(
6417										"interactivityType",
6418									));
6419								}
6420								r#interactivity_type_property = Some({
6421									struct DeserializeWith(Vec<InteractivityTypeProperty>);
6422									impl<'de> Deserialize<'de> for DeserializeWith {
6423										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6424										where
6425											D: Deserializer<'de>,
6426										{
6427											Ok(DeserializeWith(serde_with::As::<
6428												serde_with::OneOrMany<serde_with::Same>,
6429											>::deserialize(deserializer)?))
6430										}
6431									}
6432									match map.next_value::<DeserializeWith>() {
6433										Ok(deserialize_with) => deserialize_with.0,
6434										Err(err) => {
6435											return Err(err);
6436										}
6437									}
6438								});
6439							}
6440							Field::InterpretedAsClaim => {
6441								if r#interpreted_as_claim_property.is_some() {
6442									return Err(<A::Error as de::Error>::duplicate_field(
6443										"interpretedAsClaim",
6444									));
6445								}
6446								r#interpreted_as_claim_property = Some({
6447									struct DeserializeWith(Vec<InterpretedAsClaimProperty>);
6448									impl<'de> Deserialize<'de> for DeserializeWith {
6449										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6450										where
6451											D: Deserializer<'de>,
6452										{
6453											Ok(DeserializeWith(serde_with::As::<
6454												serde_with::OneOrMany<serde_with::Same>,
6455											>::deserialize(deserializer)?))
6456										}
6457									}
6458									match map.next_value::<DeserializeWith>() {
6459										Ok(deserialize_with) => deserialize_with.0,
6460										Err(err) => {
6461											return Err(err);
6462										}
6463									}
6464								});
6465							}
6466							Field::IsAccessibleForFree => {
6467								if r#is_accessible_for_free_property.is_some() {
6468									return Err(<A::Error as de::Error>::duplicate_field(
6469										"isAccessibleForFree",
6470									));
6471								}
6472								r#is_accessible_for_free_property = Some({
6473									struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
6474									impl<'de> Deserialize<'de> for DeserializeWith {
6475										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6476										where
6477											D: Deserializer<'de>,
6478										{
6479											Ok(DeserializeWith(serde_with::As::<
6480												serde_with::OneOrMany<serde_with::Same>,
6481											>::deserialize(deserializer)?))
6482										}
6483									}
6484									match map.next_value::<DeserializeWith>() {
6485										Ok(deserialize_with) => deserialize_with.0,
6486										Err(err) => {
6487											return Err(err);
6488										}
6489									}
6490								});
6491							}
6492							Field::IsBasedOn => {
6493								if r#is_based_on_property.is_some() {
6494									return Err(<A::Error as de::Error>::duplicate_field(
6495										"isBasedOn",
6496									));
6497								}
6498								r#is_based_on_property = Some({
6499									struct DeserializeWith(Vec<IsBasedOnProperty>);
6500									impl<'de> Deserialize<'de> for DeserializeWith {
6501										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6502										where
6503											D: Deserializer<'de>,
6504										{
6505											Ok(DeserializeWith(serde_with::As::<
6506												serde_with::OneOrMany<serde_with::Same>,
6507											>::deserialize(deserializer)?))
6508										}
6509									}
6510									match map.next_value::<DeserializeWith>() {
6511										Ok(deserialize_with) => deserialize_with.0,
6512										Err(err) => {
6513											return Err(err);
6514										}
6515									}
6516								});
6517							}
6518							Field::IsBasedOnUrl => {
6519								if r#is_based_on_url_property.is_some() {
6520									return Err(<A::Error as de::Error>::duplicate_field(
6521										"isBasedOnUrl",
6522									));
6523								}
6524								r#is_based_on_url_property = Some({
6525									struct DeserializeWith(Vec<IsBasedOnUrlProperty>);
6526									impl<'de> Deserialize<'de> for DeserializeWith {
6527										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6528										where
6529											D: Deserializer<'de>,
6530										{
6531											Ok(DeserializeWith(serde_with::As::<
6532												serde_with::OneOrMany<serde_with::Same>,
6533											>::deserialize(deserializer)?))
6534										}
6535									}
6536									match map.next_value::<DeserializeWith>() {
6537										Ok(deserialize_with) => deserialize_with.0,
6538										Err(err) => {
6539											return Err(err);
6540										}
6541									}
6542								});
6543							}
6544							Field::IsFamilyFriendly => {
6545								if r#is_family_friendly_property.is_some() {
6546									return Err(<A::Error as de::Error>::duplicate_field(
6547										"isFamilyFriendly",
6548									));
6549								}
6550								r#is_family_friendly_property = Some({
6551									struct DeserializeWith(Vec<IsFamilyFriendlyProperty>);
6552									impl<'de> Deserialize<'de> for DeserializeWith {
6553										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6554										where
6555											D: Deserializer<'de>,
6556										{
6557											Ok(DeserializeWith(serde_with::As::<
6558												serde_with::OneOrMany<serde_with::Same>,
6559											>::deserialize(deserializer)?))
6560										}
6561									}
6562									match map.next_value::<DeserializeWith>() {
6563										Ok(deserialize_with) => deserialize_with.0,
6564										Err(err) => {
6565											return Err(err);
6566										}
6567									}
6568								});
6569							}
6570							Field::IsPartOf => {
6571								if r#is_part_of_property.is_some() {
6572									return Err(<A::Error as de::Error>::duplicate_field(
6573										"isPartOf",
6574									));
6575								}
6576								r#is_part_of_property = Some({
6577									struct DeserializeWith(Vec<IsPartOfProperty>);
6578									impl<'de> Deserialize<'de> for DeserializeWith {
6579										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6580										where
6581											D: Deserializer<'de>,
6582										{
6583											Ok(DeserializeWith(serde_with::As::<
6584												serde_with::OneOrMany<serde_with::Same>,
6585											>::deserialize(deserializer)?))
6586										}
6587									}
6588									match map.next_value::<DeserializeWith>() {
6589										Ok(deserialize_with) => deserialize_with.0,
6590										Err(err) => {
6591											return Err(err);
6592										}
6593									}
6594								});
6595							}
6596							Field::Keywords => {
6597								if r#keywords_property.is_some() {
6598									return Err(<A::Error as de::Error>::duplicate_field(
6599										"keywords",
6600									));
6601								}
6602								r#keywords_property = Some({
6603									struct DeserializeWith(Vec<KeywordsProperty>);
6604									impl<'de> Deserialize<'de> for DeserializeWith {
6605										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6606										where
6607											D: Deserializer<'de>,
6608										{
6609											Ok(DeserializeWith(serde_with::As::<
6610												serde_with::OneOrMany<serde_with::Same>,
6611											>::deserialize(deserializer)?))
6612										}
6613									}
6614									match map.next_value::<DeserializeWith>() {
6615										Ok(deserialize_with) => deserialize_with.0,
6616										Err(err) => {
6617											return Err(err);
6618										}
6619									}
6620								});
6621							}
6622							Field::LearningResourceType => {
6623								if r#learning_resource_type_property.is_some() {
6624									return Err(<A::Error as de::Error>::duplicate_field(
6625										"learningResourceType",
6626									));
6627								}
6628								r#learning_resource_type_property = Some({
6629									struct DeserializeWith(Vec<LearningResourceTypeProperty>);
6630									impl<'de> Deserialize<'de> for DeserializeWith {
6631										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6632										where
6633											D: Deserializer<'de>,
6634										{
6635											Ok(DeserializeWith(serde_with::As::<
6636												serde_with::OneOrMany<serde_with::Same>,
6637											>::deserialize(deserializer)?))
6638										}
6639									}
6640									match map.next_value::<DeserializeWith>() {
6641										Ok(deserialize_with) => deserialize_with.0,
6642										Err(err) => {
6643											return Err(err);
6644										}
6645									}
6646								});
6647							}
6648							Field::License => {
6649								if r#license_property.is_some() {
6650									return Err(<A::Error as de::Error>::duplicate_field(
6651										"license",
6652									));
6653								}
6654								r#license_property = Some({
6655									struct DeserializeWith(Vec<LicenseProperty>);
6656									impl<'de> Deserialize<'de> for DeserializeWith {
6657										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6658										where
6659											D: Deserializer<'de>,
6660										{
6661											Ok(DeserializeWith(serde_with::As::<
6662												serde_with::OneOrMany<serde_with::Same>,
6663											>::deserialize(deserializer)?))
6664										}
6665									}
6666									match map.next_value::<DeserializeWith>() {
6667										Ok(deserialize_with) => deserialize_with.0,
6668										Err(err) => {
6669											return Err(err);
6670										}
6671									}
6672								});
6673							}
6674							Field::LocationCreated => {
6675								if r#location_created_property.is_some() {
6676									return Err(<A::Error as de::Error>::duplicate_field(
6677										"locationCreated",
6678									));
6679								}
6680								r#location_created_property = Some({
6681									struct DeserializeWith(Vec<LocationCreatedProperty>);
6682									impl<'de> Deserialize<'de> for DeserializeWith {
6683										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6684										where
6685											D: Deserializer<'de>,
6686										{
6687											Ok(DeserializeWith(serde_with::As::<
6688												serde_with::OneOrMany<serde_with::Same>,
6689											>::deserialize(deserializer)?))
6690										}
6691									}
6692									match map.next_value::<DeserializeWith>() {
6693										Ok(deserialize_with) => deserialize_with.0,
6694										Err(err) => {
6695											return Err(err);
6696										}
6697									}
6698								});
6699							}
6700							Field::MainEntity => {
6701								if r#main_entity_property.is_some() {
6702									return Err(<A::Error as de::Error>::duplicate_field(
6703										"mainEntity",
6704									));
6705								}
6706								r#main_entity_property = Some({
6707									struct DeserializeWith(Vec<MainEntityProperty>);
6708									impl<'de> Deserialize<'de> for DeserializeWith {
6709										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6710										where
6711											D: Deserializer<'de>,
6712										{
6713											Ok(DeserializeWith(serde_with::As::<
6714												serde_with::OneOrMany<serde_with::Same>,
6715											>::deserialize(deserializer)?))
6716										}
6717									}
6718									match map.next_value::<DeserializeWith>() {
6719										Ok(deserialize_with) => deserialize_with.0,
6720										Err(err) => {
6721											return Err(err);
6722										}
6723									}
6724								});
6725							}
6726							Field::Maintainer => {
6727								if r#maintainer_property.is_some() {
6728									return Err(<A::Error as de::Error>::duplicate_field(
6729										"maintainer",
6730									));
6731								}
6732								r#maintainer_property = Some({
6733									struct DeserializeWith(Vec<MaintainerProperty>);
6734									impl<'de> Deserialize<'de> for DeserializeWith {
6735										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6736										where
6737											D: Deserializer<'de>,
6738										{
6739											Ok(DeserializeWith(serde_with::As::<
6740												serde_with::OneOrMany<serde_with::Same>,
6741											>::deserialize(deserializer)?))
6742										}
6743									}
6744									match map.next_value::<DeserializeWith>() {
6745										Ok(deserialize_with) => deserialize_with.0,
6746										Err(err) => {
6747											return Err(err);
6748										}
6749									}
6750								});
6751							}
6752							Field::Material => {
6753								if r#material_property.is_some() {
6754									return Err(<A::Error as de::Error>::duplicate_field(
6755										"material",
6756									));
6757								}
6758								r#material_property = Some({
6759									struct DeserializeWith(Vec<MaterialProperty>);
6760									impl<'de> Deserialize<'de> for DeserializeWith {
6761										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6762										where
6763											D: Deserializer<'de>,
6764										{
6765											Ok(DeserializeWith(serde_with::As::<
6766												serde_with::OneOrMany<serde_with::Same>,
6767											>::deserialize(deserializer)?))
6768										}
6769									}
6770									match map.next_value::<DeserializeWith>() {
6771										Ok(deserialize_with) => deserialize_with.0,
6772										Err(err) => {
6773											return Err(err);
6774										}
6775									}
6776								});
6777							}
6778							Field::MaterialExtent => {
6779								if r#material_extent_property.is_some() {
6780									return Err(<A::Error as de::Error>::duplicate_field(
6781										"materialExtent",
6782									));
6783								}
6784								r#material_extent_property = Some({
6785									struct DeserializeWith(Vec<MaterialExtentProperty>);
6786									impl<'de> Deserialize<'de> for DeserializeWith {
6787										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6788										where
6789											D: Deserializer<'de>,
6790										{
6791											Ok(DeserializeWith(serde_with::As::<
6792												serde_with::OneOrMany<serde_with::Same>,
6793											>::deserialize(deserializer)?))
6794										}
6795									}
6796									match map.next_value::<DeserializeWith>() {
6797										Ok(deserialize_with) => deserialize_with.0,
6798										Err(err) => {
6799											return Err(err);
6800										}
6801									}
6802								});
6803							}
6804							Field::Mentions => {
6805								if r#mentions_property.is_some() {
6806									return Err(<A::Error as de::Error>::duplicate_field(
6807										"mentions",
6808									));
6809								}
6810								r#mentions_property = Some({
6811									struct DeserializeWith(Vec<MentionsProperty>);
6812									impl<'de> Deserialize<'de> for DeserializeWith {
6813										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6814										where
6815											D: Deserializer<'de>,
6816										{
6817											Ok(DeserializeWith(serde_with::As::<
6818												serde_with::OneOrMany<serde_with::Same>,
6819											>::deserialize(deserializer)?))
6820										}
6821									}
6822									match map.next_value::<DeserializeWith>() {
6823										Ok(deserialize_with) => deserialize_with.0,
6824										Err(err) => {
6825											return Err(err);
6826										}
6827									}
6828								});
6829							}
6830							Field::Offers => {
6831								if r#offers_property.is_some() {
6832									return Err(<A::Error as de::Error>::duplicate_field("offers"));
6833								}
6834								r#offers_property = Some({
6835									struct DeserializeWith(Vec<OffersProperty>);
6836									impl<'de> Deserialize<'de> for DeserializeWith {
6837										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6838										where
6839											D: Deserializer<'de>,
6840										{
6841											Ok(DeserializeWith(serde_with::As::<
6842												serde_with::OneOrMany<serde_with::Same>,
6843											>::deserialize(deserializer)?))
6844										}
6845									}
6846									match map.next_value::<DeserializeWith>() {
6847										Ok(deserialize_with) => deserialize_with.0,
6848										Err(err) => {
6849											return Err(err);
6850										}
6851									}
6852								});
6853							}
6854							Field::Pattern => {
6855								if r#pattern_property.is_some() {
6856									return Err(<A::Error as de::Error>::duplicate_field(
6857										"pattern",
6858									));
6859								}
6860								r#pattern_property = Some({
6861									struct DeserializeWith(Vec<PatternProperty>);
6862									impl<'de> Deserialize<'de> for DeserializeWith {
6863										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6864										where
6865											D: Deserializer<'de>,
6866										{
6867											Ok(DeserializeWith(serde_with::As::<
6868												serde_with::OneOrMany<serde_with::Same>,
6869											>::deserialize(deserializer)?))
6870										}
6871									}
6872									match map.next_value::<DeserializeWith>() {
6873										Ok(deserialize_with) => deserialize_with.0,
6874										Err(err) => {
6875											return Err(err);
6876										}
6877									}
6878								});
6879							}
6880							Field::Position => {
6881								if r#position_property.is_some() {
6882									return Err(<A::Error as de::Error>::duplicate_field(
6883										"position",
6884									));
6885								}
6886								r#position_property = Some({
6887									struct DeserializeWith(Vec<PositionProperty>);
6888									impl<'de> Deserialize<'de> for DeserializeWith {
6889										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6890										where
6891											D: Deserializer<'de>,
6892										{
6893											Ok(DeserializeWith(serde_with::As::<
6894												serde_with::OneOrMany<serde_with::Same>,
6895											>::deserialize(deserializer)?))
6896										}
6897									}
6898									match map.next_value::<DeserializeWith>() {
6899										Ok(deserialize_with) => deserialize_with.0,
6900										Err(err) => {
6901											return Err(err);
6902										}
6903									}
6904								});
6905							}
6906							Field::Producer => {
6907								if r#producer_property.is_some() {
6908									return Err(<A::Error as de::Error>::duplicate_field(
6909										"producer",
6910									));
6911								}
6912								r#producer_property = Some({
6913									struct DeserializeWith(Vec<ProducerProperty>);
6914									impl<'de> Deserialize<'de> for DeserializeWith {
6915										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6916										where
6917											D: Deserializer<'de>,
6918										{
6919											Ok(DeserializeWith(serde_with::As::<
6920												serde_with::OneOrMany<serde_with::Same>,
6921											>::deserialize(deserializer)?))
6922										}
6923									}
6924									match map.next_value::<DeserializeWith>() {
6925										Ok(deserialize_with) => deserialize_with.0,
6926										Err(err) => {
6927											return Err(err);
6928										}
6929									}
6930								});
6931							}
6932							Field::Provider => {
6933								if r#provider_property.is_some() {
6934									return Err(<A::Error as de::Error>::duplicate_field(
6935										"provider",
6936									));
6937								}
6938								r#provider_property = Some({
6939									struct DeserializeWith(Vec<ProviderProperty>);
6940									impl<'de> Deserialize<'de> for DeserializeWith {
6941										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6942										where
6943											D: Deserializer<'de>,
6944										{
6945											Ok(DeserializeWith(serde_with::As::<
6946												serde_with::OneOrMany<serde_with::Same>,
6947											>::deserialize(deserializer)?))
6948										}
6949									}
6950									match map.next_value::<DeserializeWith>() {
6951										Ok(deserialize_with) => deserialize_with.0,
6952										Err(err) => {
6953											return Err(err);
6954										}
6955									}
6956								});
6957							}
6958							Field::Publication => {
6959								if r#publication_property.is_some() {
6960									return Err(<A::Error as de::Error>::duplicate_field(
6961										"publication",
6962									));
6963								}
6964								r#publication_property = Some({
6965									struct DeserializeWith(Vec<PublicationProperty>);
6966									impl<'de> Deserialize<'de> for DeserializeWith {
6967										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6968										where
6969											D: Deserializer<'de>,
6970										{
6971											Ok(DeserializeWith(serde_with::As::<
6972												serde_with::OneOrMany<serde_with::Same>,
6973											>::deserialize(deserializer)?))
6974										}
6975									}
6976									match map.next_value::<DeserializeWith>() {
6977										Ok(deserialize_with) => deserialize_with.0,
6978										Err(err) => {
6979											return Err(err);
6980										}
6981									}
6982								});
6983							}
6984							Field::Publisher => {
6985								if r#publisher_property.is_some() {
6986									return Err(<A::Error as de::Error>::duplicate_field(
6987										"publisher",
6988									));
6989								}
6990								r#publisher_property = Some({
6991									struct DeserializeWith(Vec<PublisherProperty>);
6992									impl<'de> Deserialize<'de> for DeserializeWith {
6993										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6994										where
6995											D: Deserializer<'de>,
6996										{
6997											Ok(DeserializeWith(serde_with::As::<
6998												serde_with::OneOrMany<serde_with::Same>,
6999											>::deserialize(deserializer)?))
7000										}
7001									}
7002									match map.next_value::<DeserializeWith>() {
7003										Ok(deserialize_with) => deserialize_with.0,
7004										Err(err) => {
7005											return Err(err);
7006										}
7007									}
7008								});
7009							}
7010							Field::PublisherImprint => {
7011								if r#publisher_imprint_property.is_some() {
7012									return Err(<A::Error as de::Error>::duplicate_field(
7013										"publisherImprint",
7014									));
7015								}
7016								r#publisher_imprint_property = Some({
7017									struct DeserializeWith(Vec<PublisherImprintProperty>);
7018									impl<'de> Deserialize<'de> for DeserializeWith {
7019										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7020										where
7021											D: Deserializer<'de>,
7022										{
7023											Ok(DeserializeWith(serde_with::As::<
7024												serde_with::OneOrMany<serde_with::Same>,
7025											>::deserialize(deserializer)?))
7026										}
7027									}
7028									match map.next_value::<DeserializeWith>() {
7029										Ok(deserialize_with) => deserialize_with.0,
7030										Err(err) => {
7031											return Err(err);
7032										}
7033									}
7034								});
7035							}
7036							Field::PublishingPrinciples => {
7037								if r#publishing_principles_property.is_some() {
7038									return Err(<A::Error as de::Error>::duplicate_field(
7039										"publishingPrinciples",
7040									));
7041								}
7042								r#publishing_principles_property = Some({
7043									struct DeserializeWith(Vec<PublishingPrinciplesProperty>);
7044									impl<'de> Deserialize<'de> for DeserializeWith {
7045										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7046										where
7047											D: Deserializer<'de>,
7048										{
7049											Ok(DeserializeWith(serde_with::As::<
7050												serde_with::OneOrMany<serde_with::Same>,
7051											>::deserialize(deserializer)?))
7052										}
7053									}
7054									match map.next_value::<DeserializeWith>() {
7055										Ok(deserialize_with) => deserialize_with.0,
7056										Err(err) => {
7057											return Err(err);
7058										}
7059									}
7060								});
7061							}
7062							Field::RecordedAt => {
7063								if r#recorded_at_property.is_some() {
7064									return Err(<A::Error as de::Error>::duplicate_field(
7065										"recordedAt",
7066									));
7067								}
7068								r#recorded_at_property = Some({
7069									struct DeserializeWith(Vec<RecordedAtProperty>);
7070									impl<'de> Deserialize<'de> for DeserializeWith {
7071										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7072										where
7073											D: Deserializer<'de>,
7074										{
7075											Ok(DeserializeWith(serde_with::As::<
7076												serde_with::OneOrMany<serde_with::Same>,
7077											>::deserialize(deserializer)?))
7078										}
7079									}
7080									match map.next_value::<DeserializeWith>() {
7081										Ok(deserialize_with) => deserialize_with.0,
7082										Err(err) => {
7083											return Err(err);
7084										}
7085									}
7086								});
7087							}
7088							Field::ReleasedEvent => {
7089								if r#released_event_property.is_some() {
7090									return Err(<A::Error as de::Error>::duplicate_field(
7091										"releasedEvent",
7092									));
7093								}
7094								r#released_event_property = Some({
7095									struct DeserializeWith(Vec<ReleasedEventProperty>);
7096									impl<'de> Deserialize<'de> for DeserializeWith {
7097										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7098										where
7099											D: Deserializer<'de>,
7100										{
7101											Ok(DeserializeWith(serde_with::As::<
7102												serde_with::OneOrMany<serde_with::Same>,
7103											>::deserialize(deserializer)?))
7104										}
7105									}
7106									match map.next_value::<DeserializeWith>() {
7107										Ok(deserialize_with) => deserialize_with.0,
7108										Err(err) => {
7109											return Err(err);
7110										}
7111									}
7112								});
7113							}
7114							Field::Review => {
7115								if r#review_property.is_some() {
7116									return Err(<A::Error as de::Error>::duplicate_field("review"));
7117								}
7118								r#review_property = Some({
7119									struct DeserializeWith(Vec<ReviewProperty>);
7120									impl<'de> Deserialize<'de> for DeserializeWith {
7121										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7122										where
7123											D: Deserializer<'de>,
7124										{
7125											Ok(DeserializeWith(serde_with::As::<
7126												serde_with::OneOrMany<serde_with::Same>,
7127											>::deserialize(deserializer)?))
7128										}
7129									}
7130									match map.next_value::<DeserializeWith>() {
7131										Ok(deserialize_with) => deserialize_with.0,
7132										Err(err) => {
7133											return Err(err);
7134										}
7135									}
7136								});
7137							}
7138							Field::Reviews => {
7139								if r#reviews_property.is_some() {
7140									return Err(<A::Error as de::Error>::duplicate_field(
7141										"reviews",
7142									));
7143								}
7144								r#reviews_property = Some({
7145									struct DeserializeWith(Vec<ReviewsProperty>);
7146									impl<'de> Deserialize<'de> for DeserializeWith {
7147										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7148										where
7149											D: Deserializer<'de>,
7150										{
7151											Ok(DeserializeWith(serde_with::As::<
7152												serde_with::OneOrMany<serde_with::Same>,
7153											>::deserialize(deserializer)?))
7154										}
7155									}
7156									match map.next_value::<DeserializeWith>() {
7157										Ok(deserialize_with) => deserialize_with.0,
7158										Err(err) => {
7159											return Err(err);
7160										}
7161									}
7162								});
7163							}
7164							Field::SchemaVersion => {
7165								if r#schema_version_property.is_some() {
7166									return Err(<A::Error as de::Error>::duplicate_field(
7167										"schemaVersion",
7168									));
7169								}
7170								r#schema_version_property = Some({
7171									struct DeserializeWith(Vec<SchemaVersionProperty>);
7172									impl<'de> Deserialize<'de> for DeserializeWith {
7173										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7174										where
7175											D: Deserializer<'de>,
7176										{
7177											Ok(DeserializeWith(serde_with::As::<
7178												serde_with::OneOrMany<serde_with::Same>,
7179											>::deserialize(deserializer)?))
7180										}
7181									}
7182									match map.next_value::<DeserializeWith>() {
7183										Ok(deserialize_with) => deserialize_with.0,
7184										Err(err) => {
7185											return Err(err);
7186										}
7187									}
7188								});
7189							}
7190							Field::SdDatePublished => {
7191								if r#sd_date_published_property.is_some() {
7192									return Err(<A::Error as de::Error>::duplicate_field(
7193										"sdDatePublished",
7194									));
7195								}
7196								r#sd_date_published_property = Some({
7197									struct DeserializeWith(Vec<SdDatePublishedProperty>);
7198									impl<'de> Deserialize<'de> for DeserializeWith {
7199										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7200										where
7201											D: Deserializer<'de>,
7202										{
7203											Ok(DeserializeWith(serde_with::As::<
7204												serde_with::OneOrMany<serde_with::Same>,
7205											>::deserialize(deserializer)?))
7206										}
7207									}
7208									match map.next_value::<DeserializeWith>() {
7209										Ok(deserialize_with) => deserialize_with.0,
7210										Err(err) => {
7211											return Err(err);
7212										}
7213									}
7214								});
7215							}
7216							Field::SdLicense => {
7217								if r#sd_license_property.is_some() {
7218									return Err(<A::Error as de::Error>::duplicate_field(
7219										"sdLicense",
7220									));
7221								}
7222								r#sd_license_property = Some({
7223									struct DeserializeWith(Vec<SdLicenseProperty>);
7224									impl<'de> Deserialize<'de> for DeserializeWith {
7225										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7226										where
7227											D: Deserializer<'de>,
7228										{
7229											Ok(DeserializeWith(serde_with::As::<
7230												serde_with::OneOrMany<serde_with::Same>,
7231											>::deserialize(deserializer)?))
7232										}
7233									}
7234									match map.next_value::<DeserializeWith>() {
7235										Ok(deserialize_with) => deserialize_with.0,
7236										Err(err) => {
7237											return Err(err);
7238										}
7239									}
7240								});
7241							}
7242							Field::SdPublisher => {
7243								if r#sd_publisher_property.is_some() {
7244									return Err(<A::Error as de::Error>::duplicate_field(
7245										"sdPublisher",
7246									));
7247								}
7248								r#sd_publisher_property = Some({
7249									struct DeserializeWith(Vec<SdPublisherProperty>);
7250									impl<'de> Deserialize<'de> for DeserializeWith {
7251										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7252										where
7253											D: Deserializer<'de>,
7254										{
7255											Ok(DeserializeWith(serde_with::As::<
7256												serde_with::OneOrMany<serde_with::Same>,
7257											>::deserialize(deserializer)?))
7258										}
7259									}
7260									match map.next_value::<DeserializeWith>() {
7261										Ok(deserialize_with) => deserialize_with.0,
7262										Err(err) => {
7263											return Err(err);
7264										}
7265									}
7266								});
7267							}
7268							Field::Size => {
7269								if r#size_property.is_some() {
7270									return Err(<A::Error as de::Error>::duplicate_field("size"));
7271								}
7272								r#size_property = Some({
7273									struct DeserializeWith(Vec<SizeProperty>);
7274									impl<'de> Deserialize<'de> for DeserializeWith {
7275										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7276										where
7277											D: Deserializer<'de>,
7278										{
7279											Ok(DeserializeWith(serde_with::As::<
7280												serde_with::OneOrMany<serde_with::Same>,
7281											>::deserialize(deserializer)?))
7282										}
7283									}
7284									match map.next_value::<DeserializeWith>() {
7285										Ok(deserialize_with) => deserialize_with.0,
7286										Err(err) => {
7287											return Err(err);
7288										}
7289									}
7290								});
7291							}
7292							Field::SourceOrganization => {
7293								if r#source_organization_property.is_some() {
7294									return Err(<A::Error as de::Error>::duplicate_field(
7295										"sourceOrganization",
7296									));
7297								}
7298								r#source_organization_property = Some({
7299									struct DeserializeWith(Vec<SourceOrganizationProperty>);
7300									impl<'de> Deserialize<'de> for DeserializeWith {
7301										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7302										where
7303											D: Deserializer<'de>,
7304										{
7305											Ok(DeserializeWith(serde_with::As::<
7306												serde_with::OneOrMany<serde_with::Same>,
7307											>::deserialize(deserializer)?))
7308										}
7309									}
7310									match map.next_value::<DeserializeWith>() {
7311										Ok(deserialize_with) => deserialize_with.0,
7312										Err(err) => {
7313											return Err(err);
7314										}
7315									}
7316								});
7317							}
7318							Field::Spatial => {
7319								if r#spatial_property.is_some() {
7320									return Err(<A::Error as de::Error>::duplicate_field(
7321										"spatial",
7322									));
7323								}
7324								r#spatial_property = Some({
7325									struct DeserializeWith(Vec<SpatialProperty>);
7326									impl<'de> Deserialize<'de> for DeserializeWith {
7327										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7328										where
7329											D: Deserializer<'de>,
7330										{
7331											Ok(DeserializeWith(serde_with::As::<
7332												serde_with::OneOrMany<serde_with::Same>,
7333											>::deserialize(deserializer)?))
7334										}
7335									}
7336									match map.next_value::<DeserializeWith>() {
7337										Ok(deserialize_with) => deserialize_with.0,
7338										Err(err) => {
7339											return Err(err);
7340										}
7341									}
7342								});
7343							}
7344							Field::SpatialCoverage => {
7345								if r#spatial_coverage_property.is_some() {
7346									return Err(<A::Error as de::Error>::duplicate_field(
7347										"spatialCoverage",
7348									));
7349								}
7350								r#spatial_coverage_property = Some({
7351									struct DeserializeWith(Vec<SpatialCoverageProperty>);
7352									impl<'de> Deserialize<'de> for DeserializeWith {
7353										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7354										where
7355											D: Deserializer<'de>,
7356										{
7357											Ok(DeserializeWith(serde_with::As::<
7358												serde_with::OneOrMany<serde_with::Same>,
7359											>::deserialize(deserializer)?))
7360										}
7361									}
7362									match map.next_value::<DeserializeWith>() {
7363										Ok(deserialize_with) => deserialize_with.0,
7364										Err(err) => {
7365											return Err(err);
7366										}
7367									}
7368								});
7369							}
7370							Field::Sponsor => {
7371								if r#sponsor_property.is_some() {
7372									return Err(<A::Error as de::Error>::duplicate_field(
7373										"sponsor",
7374									));
7375								}
7376								r#sponsor_property = Some({
7377									struct DeserializeWith(Vec<SponsorProperty>);
7378									impl<'de> Deserialize<'de> for DeserializeWith {
7379										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7380										where
7381											D: Deserializer<'de>,
7382										{
7383											Ok(DeserializeWith(serde_with::As::<
7384												serde_with::OneOrMany<serde_with::Same>,
7385											>::deserialize(deserializer)?))
7386										}
7387									}
7388									match map.next_value::<DeserializeWith>() {
7389										Ok(deserialize_with) => deserialize_with.0,
7390										Err(err) => {
7391											return Err(err);
7392										}
7393									}
7394								});
7395							}
7396							Field::Teaches => {
7397								if r#teaches_property.is_some() {
7398									return Err(<A::Error as de::Error>::duplicate_field(
7399										"teaches",
7400									));
7401								}
7402								r#teaches_property = Some({
7403									struct DeserializeWith(Vec<TeachesProperty>);
7404									impl<'de> Deserialize<'de> for DeserializeWith {
7405										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7406										where
7407											D: Deserializer<'de>,
7408										{
7409											Ok(DeserializeWith(serde_with::As::<
7410												serde_with::OneOrMany<serde_with::Same>,
7411											>::deserialize(deserializer)?))
7412										}
7413									}
7414									match map.next_value::<DeserializeWith>() {
7415										Ok(deserialize_with) => deserialize_with.0,
7416										Err(err) => {
7417											return Err(err);
7418										}
7419									}
7420								});
7421							}
7422							Field::Temporal => {
7423								if r#temporal_property.is_some() {
7424									return Err(<A::Error as de::Error>::duplicate_field(
7425										"temporal",
7426									));
7427								}
7428								r#temporal_property = Some({
7429									struct DeserializeWith(Vec<TemporalProperty>);
7430									impl<'de> Deserialize<'de> for DeserializeWith {
7431										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7432										where
7433											D: Deserializer<'de>,
7434										{
7435											Ok(DeserializeWith(serde_with::As::<
7436												serde_with::OneOrMany<serde_with::Same>,
7437											>::deserialize(deserializer)?))
7438										}
7439									}
7440									match map.next_value::<DeserializeWith>() {
7441										Ok(deserialize_with) => deserialize_with.0,
7442										Err(err) => {
7443											return Err(err);
7444										}
7445									}
7446								});
7447							}
7448							Field::TemporalCoverage => {
7449								if r#temporal_coverage_property.is_some() {
7450									return Err(<A::Error as de::Error>::duplicate_field(
7451										"temporalCoverage",
7452									));
7453								}
7454								r#temporal_coverage_property = Some({
7455									struct DeserializeWith(Vec<TemporalCoverageProperty>);
7456									impl<'de> Deserialize<'de> for DeserializeWith {
7457										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7458										where
7459											D: Deserializer<'de>,
7460										{
7461											Ok(DeserializeWith(serde_with::As::<
7462												serde_with::OneOrMany<serde_with::Same>,
7463											>::deserialize(deserializer)?))
7464										}
7465									}
7466									match map.next_value::<DeserializeWith>() {
7467										Ok(deserialize_with) => deserialize_with.0,
7468										Err(err) => {
7469											return Err(err);
7470										}
7471									}
7472								});
7473							}
7474							Field::Text => {
7475								if r#text_property.is_some() {
7476									return Err(<A::Error as de::Error>::duplicate_field("text"));
7477								}
7478								r#text_property = Some({
7479									struct DeserializeWith(Vec<TextProperty>);
7480									impl<'de> Deserialize<'de> for DeserializeWith {
7481										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7482										where
7483											D: Deserializer<'de>,
7484										{
7485											Ok(DeserializeWith(serde_with::As::<
7486												serde_with::OneOrMany<serde_with::Same>,
7487											>::deserialize(deserializer)?))
7488										}
7489									}
7490									match map.next_value::<DeserializeWith>() {
7491										Ok(deserialize_with) => deserialize_with.0,
7492										Err(err) => {
7493											return Err(err);
7494										}
7495									}
7496								});
7497							}
7498							Field::Thumbnail => {
7499								if r#thumbnail_property.is_some() {
7500									return Err(<A::Error as de::Error>::duplicate_field(
7501										"thumbnail",
7502									));
7503								}
7504								r#thumbnail_property = Some({
7505									struct DeserializeWith(Vec<ThumbnailProperty>);
7506									impl<'de> Deserialize<'de> for DeserializeWith {
7507										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7508										where
7509											D: Deserializer<'de>,
7510										{
7511											Ok(DeserializeWith(serde_with::As::<
7512												serde_with::OneOrMany<serde_with::Same>,
7513											>::deserialize(deserializer)?))
7514										}
7515									}
7516									match map.next_value::<DeserializeWith>() {
7517										Ok(deserialize_with) => deserialize_with.0,
7518										Err(err) => {
7519											return Err(err);
7520										}
7521									}
7522								});
7523							}
7524							Field::ThumbnailUrl => {
7525								if r#thumbnail_url_property.is_some() {
7526									return Err(<A::Error as de::Error>::duplicate_field(
7527										"thumbnailUrl",
7528									));
7529								}
7530								r#thumbnail_url_property = Some({
7531									struct DeserializeWith(Vec<ThumbnailUrlProperty>);
7532									impl<'de> Deserialize<'de> for DeserializeWith {
7533										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7534										where
7535											D: Deserializer<'de>,
7536										{
7537											Ok(DeserializeWith(serde_with::As::<
7538												serde_with::OneOrMany<serde_with::Same>,
7539											>::deserialize(deserializer)?))
7540										}
7541									}
7542									match map.next_value::<DeserializeWith>() {
7543										Ok(deserialize_with) => deserialize_with.0,
7544										Err(err) => {
7545											return Err(err);
7546										}
7547									}
7548								});
7549							}
7550							Field::TimeRequired => {
7551								if r#time_required_property.is_some() {
7552									return Err(<A::Error as de::Error>::duplicate_field(
7553										"timeRequired",
7554									));
7555								}
7556								r#time_required_property = Some({
7557									struct DeserializeWith(Vec<TimeRequiredProperty>);
7558									impl<'de> Deserialize<'de> for DeserializeWith {
7559										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7560										where
7561											D: Deserializer<'de>,
7562										{
7563											Ok(DeserializeWith(serde_with::As::<
7564												serde_with::OneOrMany<serde_with::Same>,
7565											>::deserialize(deserializer)?))
7566										}
7567									}
7568									match map.next_value::<DeserializeWith>() {
7569										Ok(deserialize_with) => deserialize_with.0,
7570										Err(err) => {
7571											return Err(err);
7572										}
7573									}
7574								});
7575							}
7576							Field::TranslationOfWork => {
7577								if r#translation_of_work_property.is_some() {
7578									return Err(<A::Error as de::Error>::duplicate_field(
7579										"translationOfWork",
7580									));
7581								}
7582								r#translation_of_work_property = Some({
7583									struct DeserializeWith(Vec<TranslationOfWorkProperty>);
7584									impl<'de> Deserialize<'de> for DeserializeWith {
7585										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7586										where
7587											D: Deserializer<'de>,
7588										{
7589											Ok(DeserializeWith(serde_with::As::<
7590												serde_with::OneOrMany<serde_with::Same>,
7591											>::deserialize(deserializer)?))
7592										}
7593									}
7594									match map.next_value::<DeserializeWith>() {
7595										Ok(deserialize_with) => deserialize_with.0,
7596										Err(err) => {
7597											return Err(err);
7598										}
7599									}
7600								});
7601							}
7602							Field::Translator => {
7603								if r#translator_property.is_some() {
7604									return Err(<A::Error as de::Error>::duplicate_field(
7605										"translator",
7606									));
7607								}
7608								r#translator_property = Some({
7609									struct DeserializeWith(Vec<TranslatorProperty>);
7610									impl<'de> Deserialize<'de> for DeserializeWith {
7611										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7612										where
7613											D: Deserializer<'de>,
7614										{
7615											Ok(DeserializeWith(serde_with::As::<
7616												serde_with::OneOrMany<serde_with::Same>,
7617											>::deserialize(deserializer)?))
7618										}
7619									}
7620									match map.next_value::<DeserializeWith>() {
7621										Ok(deserialize_with) => deserialize_with.0,
7622										Err(err) => {
7623											return Err(err);
7624										}
7625									}
7626								});
7627							}
7628							Field::TypicalAgeRange => {
7629								if r#typical_age_range_property.is_some() {
7630									return Err(<A::Error as de::Error>::duplicate_field(
7631										"typicalAgeRange",
7632									));
7633								}
7634								r#typical_age_range_property = Some({
7635									struct DeserializeWith(Vec<TypicalAgeRangeProperty>);
7636									impl<'de> Deserialize<'de> for DeserializeWith {
7637										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7638										where
7639											D: Deserializer<'de>,
7640										{
7641											Ok(DeserializeWith(serde_with::As::<
7642												serde_with::OneOrMany<serde_with::Same>,
7643											>::deserialize(deserializer)?))
7644										}
7645									}
7646									match map.next_value::<DeserializeWith>() {
7647										Ok(deserialize_with) => deserialize_with.0,
7648										Err(err) => {
7649											return Err(err);
7650										}
7651									}
7652								});
7653							}
7654							Field::UsageInfo => {
7655								if r#usage_info_property.is_some() {
7656									return Err(<A::Error as de::Error>::duplicate_field(
7657										"usageInfo",
7658									));
7659								}
7660								r#usage_info_property = Some({
7661									struct DeserializeWith(Vec<UsageInfoProperty>);
7662									impl<'de> Deserialize<'de> for DeserializeWith {
7663										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7664										where
7665											D: Deserializer<'de>,
7666										{
7667											Ok(DeserializeWith(serde_with::As::<
7668												serde_with::OneOrMany<serde_with::Same>,
7669											>::deserialize(deserializer)?))
7670										}
7671									}
7672									match map.next_value::<DeserializeWith>() {
7673										Ok(deserialize_with) => deserialize_with.0,
7674										Err(err) => {
7675											return Err(err);
7676										}
7677									}
7678								});
7679							}
7680							Field::Version => {
7681								if r#version_property.is_some() {
7682									return Err(<A::Error as de::Error>::duplicate_field(
7683										"version",
7684									));
7685								}
7686								r#version_property = Some({
7687									struct DeserializeWith(Vec<VersionProperty>);
7688									impl<'de> Deserialize<'de> for DeserializeWith {
7689										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7690										where
7691											D: Deserializer<'de>,
7692										{
7693											Ok(DeserializeWith(serde_with::As::<
7694												serde_with::OneOrMany<serde_with::Same>,
7695											>::deserialize(deserializer)?))
7696										}
7697									}
7698									match map.next_value::<DeserializeWith>() {
7699										Ok(deserialize_with) => deserialize_with.0,
7700										Err(err) => {
7701											return Err(err);
7702										}
7703									}
7704								});
7705							}
7706							Field::Video => {
7707								if r#video_property.is_some() {
7708									return Err(<A::Error as de::Error>::duplicate_field("video"));
7709								}
7710								r#video_property = Some({
7711									struct DeserializeWith(Vec<VideoProperty>);
7712									impl<'de> Deserialize<'de> for DeserializeWith {
7713										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7714										where
7715											D: Deserializer<'de>,
7716										{
7717											Ok(DeserializeWith(serde_with::As::<
7718												serde_with::OneOrMany<serde_with::Same>,
7719											>::deserialize(deserializer)?))
7720										}
7721									}
7722									match map.next_value::<DeserializeWith>() {
7723										Ok(deserialize_with) => deserialize_with.0,
7724										Err(err) => {
7725											return Err(err);
7726										}
7727									}
7728								});
7729							}
7730							Field::WorkExample => {
7731								if r#work_example_property.is_some() {
7732									return Err(<A::Error as de::Error>::duplicate_field(
7733										"workExample",
7734									));
7735								}
7736								r#work_example_property = Some({
7737									struct DeserializeWith(Vec<WorkExampleProperty>);
7738									impl<'de> Deserialize<'de> for DeserializeWith {
7739										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7740										where
7741											D: Deserializer<'de>,
7742										{
7743											Ok(DeserializeWith(serde_with::As::<
7744												serde_with::OneOrMany<serde_with::Same>,
7745											>::deserialize(deserializer)?))
7746										}
7747									}
7748									match map.next_value::<DeserializeWith>() {
7749										Ok(deserialize_with) => deserialize_with.0,
7750										Err(err) => {
7751											return Err(err);
7752										}
7753									}
7754								});
7755							}
7756							Field::WorkTranslation => {
7757								if r#work_translation_property.is_some() {
7758									return Err(<A::Error as de::Error>::duplicate_field(
7759										"workTranslation",
7760									));
7761								}
7762								r#work_translation_property = Some({
7763									struct DeserializeWith(Vec<WorkTranslationProperty>);
7764									impl<'de> Deserialize<'de> for DeserializeWith {
7765										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7766										where
7767											D: Deserializer<'de>,
7768										{
7769											Ok(DeserializeWith(serde_with::As::<
7770												serde_with::OneOrMany<serde_with::Same>,
7771											>::deserialize(deserializer)?))
7772										}
7773									}
7774									match map.next_value::<DeserializeWith>() {
7775										Ok(deserialize_with) => deserialize_with.0,
7776										Err(err) => {
7777											return Err(err);
7778										}
7779									}
7780								});
7781							}
7782							Field::Dateline => {
7783								if r#dateline_property.is_some() {
7784									return Err(<A::Error as de::Error>::duplicate_field(
7785										"dateline",
7786									));
7787								}
7788								r#dateline_property = Some({
7789									struct DeserializeWith(Vec<DatelineProperty>);
7790									impl<'de> Deserialize<'de> for DeserializeWith {
7791										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7792										where
7793											D: Deserializer<'de>,
7794										{
7795											Ok(DeserializeWith(serde_with::As::<
7796												serde_with::OneOrMany<serde_with::Same>,
7797											>::deserialize(deserializer)?))
7798										}
7799									}
7800									match map.next_value::<DeserializeWith>() {
7801										Ok(deserialize_with) => deserialize_with.0,
7802										Err(err) => {
7803											return Err(err);
7804										}
7805									}
7806								});
7807							}
7808							Field::PrintColumn => {
7809								if r#print_column_property.is_some() {
7810									return Err(<A::Error as de::Error>::duplicate_field(
7811										"printColumn",
7812									));
7813								}
7814								r#print_column_property = Some({
7815									struct DeserializeWith(Vec<PrintColumnProperty>);
7816									impl<'de> Deserialize<'de> for DeserializeWith {
7817										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7818										where
7819											D: Deserializer<'de>,
7820										{
7821											Ok(DeserializeWith(serde_with::As::<
7822												serde_with::OneOrMany<serde_with::Same>,
7823											>::deserialize(deserializer)?))
7824										}
7825									}
7826									match map.next_value::<DeserializeWith>() {
7827										Ok(deserialize_with) => deserialize_with.0,
7828										Err(err) => {
7829											return Err(err);
7830										}
7831									}
7832								});
7833							}
7834							Field::PrintEdition => {
7835								if r#print_edition_property.is_some() {
7836									return Err(<A::Error as de::Error>::duplicate_field(
7837										"printEdition",
7838									));
7839								}
7840								r#print_edition_property = Some({
7841									struct DeserializeWith(Vec<PrintEditionProperty>);
7842									impl<'de> Deserialize<'de> for DeserializeWith {
7843										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7844										where
7845											D: Deserializer<'de>,
7846										{
7847											Ok(DeserializeWith(serde_with::As::<
7848												serde_with::OneOrMany<serde_with::Same>,
7849											>::deserialize(deserializer)?))
7850										}
7851									}
7852									match map.next_value::<DeserializeWith>() {
7853										Ok(deserialize_with) => deserialize_with.0,
7854										Err(err) => {
7855											return Err(err);
7856										}
7857									}
7858								});
7859							}
7860							Field::PrintPage => {
7861								if r#print_page_property.is_some() {
7862									return Err(<A::Error as de::Error>::duplicate_field(
7863										"printPage",
7864									));
7865								}
7866								r#print_page_property = Some({
7867									struct DeserializeWith(Vec<PrintPageProperty>);
7868									impl<'de> Deserialize<'de> for DeserializeWith {
7869										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7870										where
7871											D: Deserializer<'de>,
7872										{
7873											Ok(DeserializeWith(serde_with::As::<
7874												serde_with::OneOrMany<serde_with::Same>,
7875											>::deserialize(deserializer)?))
7876										}
7877									}
7878									match map.next_value::<DeserializeWith>() {
7879										Ok(deserialize_with) => deserialize_with.0,
7880										Err(err) => {
7881											return Err(err);
7882										}
7883									}
7884								});
7885							}
7886							Field::PrintSection => {
7887								if r#print_section_property.is_some() {
7888									return Err(<A::Error as de::Error>::duplicate_field(
7889										"printSection",
7890									));
7891								}
7892								r#print_section_property = Some({
7893									struct DeserializeWith(Vec<PrintSectionProperty>);
7894									impl<'de> Deserialize<'de> for DeserializeWith {
7895										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7896										where
7897											D: Deserializer<'de>,
7898										{
7899											Ok(DeserializeWith(serde_with::As::<
7900												serde_with::OneOrMany<serde_with::Same>,
7901											>::deserialize(deserializer)?))
7902										}
7903									}
7904									match map.next_value::<DeserializeWith>() {
7905										Ok(deserialize_with) => deserialize_with.0,
7906										Err(err) => {
7907											return Err(err);
7908										}
7909									}
7910								});
7911							}
7912							Field::AssociatedClaimReview => {
7913								if r#associated_claim_review_property.is_some() {
7914									return Err(<A::Error as de::Error>::duplicate_field(
7915										"associatedClaimReview",
7916									));
7917								}
7918								r#associated_claim_review_property = Some({
7919									struct DeserializeWith(Vec<AssociatedClaimReviewProperty>);
7920									impl<'de> Deserialize<'de> for DeserializeWith {
7921										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7922										where
7923											D: Deserializer<'de>,
7924										{
7925											Ok(DeserializeWith(serde_with::As::<
7926												serde_with::OneOrMany<serde_with::Same>,
7927											>::deserialize(deserializer)?))
7928										}
7929									}
7930									match map.next_value::<DeserializeWith>() {
7931										Ok(deserialize_with) => deserialize_with.0,
7932										Err(err) => {
7933											return Err(err);
7934										}
7935									}
7936								});
7937							}
7938							Field::AssociatedMediaReview => {
7939								if r#associated_media_review_property.is_some() {
7940									return Err(<A::Error as de::Error>::duplicate_field(
7941										"associatedMediaReview",
7942									));
7943								}
7944								r#associated_media_review_property = Some({
7945									struct DeserializeWith(Vec<AssociatedMediaReviewProperty>);
7946									impl<'de> Deserialize<'de> for DeserializeWith {
7947										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7948										where
7949											D: Deserializer<'de>,
7950										{
7951											Ok(DeserializeWith(serde_with::As::<
7952												serde_with::OneOrMany<serde_with::Same>,
7953											>::deserialize(deserializer)?))
7954										}
7955									}
7956									match map.next_value::<DeserializeWith>() {
7957										Ok(deserialize_with) => deserialize_with.0,
7958										Err(err) => {
7959											return Err(err);
7960										}
7961									}
7962								});
7963							}
7964							Field::AssociatedReview => {
7965								if r#associated_review_property.is_some() {
7966									return Err(<A::Error as de::Error>::duplicate_field(
7967										"associatedReview",
7968									));
7969								}
7970								r#associated_review_property = Some({
7971									struct DeserializeWith(Vec<AssociatedReviewProperty>);
7972									impl<'de> Deserialize<'de> for DeserializeWith {
7973										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7974										where
7975											D: Deserializer<'de>,
7976										{
7977											Ok(DeserializeWith(serde_with::As::<
7978												serde_with::OneOrMany<serde_with::Same>,
7979											>::deserialize(deserializer)?))
7980										}
7981									}
7982									match map.next_value::<DeserializeWith>() {
7983										Ok(deserialize_with) => deserialize_with.0,
7984										Err(err) => {
7985											return Err(err);
7986										}
7987									}
7988								});
7989							}
7990							Field::ItemReviewed => {
7991								if r#item_reviewed_property.is_some() {
7992									return Err(<A::Error as de::Error>::duplicate_field(
7993										"itemReviewed",
7994									));
7995								}
7996								r#item_reviewed_property = Some({
7997									struct DeserializeWith(Vec<ItemReviewedProperty>);
7998									impl<'de> Deserialize<'de> for DeserializeWith {
7999										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8000										where
8001											D: Deserializer<'de>,
8002										{
8003											Ok(DeserializeWith(serde_with::As::<
8004												serde_with::OneOrMany<serde_with::Same>,
8005											>::deserialize(deserializer)?))
8006										}
8007									}
8008									match map.next_value::<DeserializeWith>() {
8009										Ok(deserialize_with) => deserialize_with.0,
8010										Err(err) => {
8011											return Err(err);
8012										}
8013									}
8014								});
8015							}
8016							Field::NegativeNotes => {
8017								if r#negative_notes_property.is_some() {
8018									return Err(<A::Error as de::Error>::duplicate_field(
8019										"negativeNotes",
8020									));
8021								}
8022								r#negative_notes_property = Some({
8023									struct DeserializeWith(Vec<NegativeNotesProperty>);
8024									impl<'de> Deserialize<'de> for DeserializeWith {
8025										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8026										where
8027											D: Deserializer<'de>,
8028										{
8029											Ok(DeserializeWith(serde_with::As::<
8030												serde_with::OneOrMany<serde_with::Same>,
8031											>::deserialize(deserializer)?))
8032										}
8033									}
8034									match map.next_value::<DeserializeWith>() {
8035										Ok(deserialize_with) => deserialize_with.0,
8036										Err(err) => {
8037											return Err(err);
8038										}
8039									}
8040								});
8041							}
8042							Field::PositiveNotes => {
8043								if r#positive_notes_property.is_some() {
8044									return Err(<A::Error as de::Error>::duplicate_field(
8045										"positiveNotes",
8046									));
8047								}
8048								r#positive_notes_property = Some({
8049									struct DeserializeWith(Vec<PositiveNotesProperty>);
8050									impl<'de> Deserialize<'de> for DeserializeWith {
8051										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8052										where
8053											D: Deserializer<'de>,
8054										{
8055											Ok(DeserializeWith(serde_with::As::<
8056												serde_with::OneOrMany<serde_with::Same>,
8057											>::deserialize(deserializer)?))
8058										}
8059									}
8060									match map.next_value::<DeserializeWith>() {
8061										Ok(deserialize_with) => deserialize_with.0,
8062										Err(err) => {
8063											return Err(err);
8064										}
8065									}
8066								});
8067							}
8068							Field::ReviewAspect => {
8069								if r#review_aspect_property.is_some() {
8070									return Err(<A::Error as de::Error>::duplicate_field(
8071										"reviewAspect",
8072									));
8073								}
8074								r#review_aspect_property = Some({
8075									struct DeserializeWith(Vec<ReviewAspectProperty>);
8076									impl<'de> Deserialize<'de> for DeserializeWith {
8077										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8078										where
8079											D: Deserializer<'de>,
8080										{
8081											Ok(DeserializeWith(serde_with::As::<
8082												serde_with::OneOrMany<serde_with::Same>,
8083											>::deserialize(deserializer)?))
8084										}
8085									}
8086									match map.next_value::<DeserializeWith>() {
8087										Ok(deserialize_with) => deserialize_with.0,
8088										Err(err) => {
8089											return Err(err);
8090										}
8091									}
8092								});
8093							}
8094							Field::ReviewBody => {
8095								if r#review_body_property.is_some() {
8096									return Err(<A::Error as de::Error>::duplicate_field(
8097										"reviewBody",
8098									));
8099								}
8100								r#review_body_property = Some({
8101									struct DeserializeWith(Vec<ReviewBodyProperty>);
8102									impl<'de> Deserialize<'de> for DeserializeWith {
8103										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8104										where
8105											D: Deserializer<'de>,
8106										{
8107											Ok(DeserializeWith(serde_with::As::<
8108												serde_with::OneOrMany<serde_with::Same>,
8109											>::deserialize(deserializer)?))
8110										}
8111									}
8112									match map.next_value::<DeserializeWith>() {
8113										Ok(deserialize_with) => deserialize_with.0,
8114										Err(err) => {
8115											return Err(err);
8116										}
8117									}
8118								});
8119							}
8120							Field::ReviewRating => {
8121								if r#review_rating_property.is_some() {
8122									return Err(<A::Error as de::Error>::duplicate_field(
8123										"reviewRating",
8124									));
8125								}
8126								r#review_rating_property = Some({
8127									struct DeserializeWith(Vec<ReviewRatingProperty>);
8128									impl<'de> Deserialize<'de> for DeserializeWith {
8129										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8130										where
8131											D: Deserializer<'de>,
8132										{
8133											Ok(DeserializeWith(serde_with::As::<
8134												serde_with::OneOrMany<serde_with::Same>,
8135											>::deserialize(deserializer)?))
8136										}
8137									}
8138									match map.next_value::<DeserializeWith>() {
8139										Ok(deserialize_with) => deserialize_with.0,
8140										Err(err) => {
8141											return Err(err);
8142										}
8143									}
8144								});
8145							}
8146							Field::AdditionalType => {
8147								if r#additional_type_property.is_some() {
8148									return Err(<A::Error as de::Error>::duplicate_field(
8149										"additionalType",
8150									));
8151								}
8152								r#additional_type_property = Some({
8153									struct DeserializeWith(Vec<AdditionalTypeProperty>);
8154									impl<'de> Deserialize<'de> for DeserializeWith {
8155										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8156										where
8157											D: Deserializer<'de>,
8158										{
8159											Ok(DeserializeWith(serde_with::As::<
8160												serde_with::OneOrMany<serde_with::Same>,
8161											>::deserialize(deserializer)?))
8162										}
8163									}
8164									match map.next_value::<DeserializeWith>() {
8165										Ok(deserialize_with) => deserialize_with.0,
8166										Err(err) => {
8167											return Err(err);
8168										}
8169									}
8170								});
8171							}
8172							Field::AlternateName => {
8173								if r#alternate_name_property.is_some() {
8174									return Err(<A::Error as de::Error>::duplicate_field(
8175										"alternateName",
8176									));
8177								}
8178								r#alternate_name_property = Some({
8179									struct DeserializeWith(Vec<AlternateNameProperty>);
8180									impl<'de> Deserialize<'de> for DeserializeWith {
8181										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8182										where
8183											D: Deserializer<'de>,
8184										{
8185											Ok(DeserializeWith(serde_with::As::<
8186												serde_with::OneOrMany<serde_with::Same>,
8187											>::deserialize(deserializer)?))
8188										}
8189									}
8190									match map.next_value::<DeserializeWith>() {
8191										Ok(deserialize_with) => deserialize_with.0,
8192										Err(err) => {
8193											return Err(err);
8194										}
8195									}
8196								});
8197							}
8198							Field::Description => {
8199								if r#description_property.is_some() {
8200									return Err(<A::Error as de::Error>::duplicate_field(
8201										"description",
8202									));
8203								}
8204								r#description_property = Some({
8205									struct DeserializeWith(Vec<DescriptionProperty>);
8206									impl<'de> Deserialize<'de> for DeserializeWith {
8207										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8208										where
8209											D: Deserializer<'de>,
8210										{
8211											Ok(DeserializeWith(serde_with::As::<
8212												serde_with::OneOrMany<serde_with::Same>,
8213											>::deserialize(deserializer)?))
8214										}
8215									}
8216									match map.next_value::<DeserializeWith>() {
8217										Ok(deserialize_with) => deserialize_with.0,
8218										Err(err) => {
8219											return Err(err);
8220										}
8221									}
8222								});
8223							}
8224							Field::DisambiguatingDescription => {
8225								if r#disambiguating_description_property.is_some() {
8226									return Err(<A::Error as de::Error>::duplicate_field(
8227										"disambiguatingDescription",
8228									));
8229								}
8230								r#disambiguating_description_property = Some({
8231									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
8232									impl<'de> Deserialize<'de> for DeserializeWith {
8233										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8234										where
8235											D: Deserializer<'de>,
8236										{
8237											Ok(DeserializeWith(serde_with::As::<
8238												serde_with::OneOrMany<serde_with::Same>,
8239											>::deserialize(deserializer)?))
8240										}
8241									}
8242									match map.next_value::<DeserializeWith>() {
8243										Ok(deserialize_with) => deserialize_with.0,
8244										Err(err) => {
8245											return Err(err);
8246										}
8247									}
8248								});
8249							}
8250							Field::Identifier => {
8251								if r#identifier_property.is_some() {
8252									return Err(<A::Error as de::Error>::duplicate_field(
8253										"identifier",
8254									));
8255								}
8256								r#identifier_property = Some({
8257									struct DeserializeWith(Vec<IdentifierProperty>);
8258									impl<'de> Deserialize<'de> for DeserializeWith {
8259										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8260										where
8261											D: Deserializer<'de>,
8262										{
8263											Ok(DeserializeWith(serde_with::As::<
8264												serde_with::OneOrMany<serde_with::Same>,
8265											>::deserialize(deserializer)?))
8266										}
8267									}
8268									match map.next_value::<DeserializeWith>() {
8269										Ok(deserialize_with) => deserialize_with.0,
8270										Err(err) => {
8271											return Err(err);
8272										}
8273									}
8274								});
8275							}
8276							Field::Image => {
8277								if r#image_property.is_some() {
8278									return Err(<A::Error as de::Error>::duplicate_field("image"));
8279								}
8280								r#image_property = Some({
8281									struct DeserializeWith(Vec<ImageProperty>);
8282									impl<'de> Deserialize<'de> for DeserializeWith {
8283										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8284										where
8285											D: Deserializer<'de>,
8286										{
8287											Ok(DeserializeWith(serde_with::As::<
8288												serde_with::OneOrMany<serde_with::Same>,
8289											>::deserialize(deserializer)?))
8290										}
8291									}
8292									match map.next_value::<DeserializeWith>() {
8293										Ok(deserialize_with) => deserialize_with.0,
8294										Err(err) => {
8295											return Err(err);
8296										}
8297									}
8298								});
8299							}
8300							Field::MainEntityOfPage => {
8301								if r#main_entity_of_page_property.is_some() {
8302									return Err(<A::Error as de::Error>::duplicate_field(
8303										"mainEntityOfPage",
8304									));
8305								}
8306								r#main_entity_of_page_property = Some({
8307									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
8308									impl<'de> Deserialize<'de> for DeserializeWith {
8309										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8310										where
8311											D: Deserializer<'de>,
8312										{
8313											Ok(DeserializeWith(serde_with::As::<
8314												serde_with::OneOrMany<serde_with::Same>,
8315											>::deserialize(deserializer)?))
8316										}
8317									}
8318									match map.next_value::<DeserializeWith>() {
8319										Ok(deserialize_with) => deserialize_with.0,
8320										Err(err) => {
8321											return Err(err);
8322										}
8323									}
8324								});
8325							}
8326							Field::Name => {
8327								if r#name_property.is_some() {
8328									return Err(<A::Error as de::Error>::duplicate_field("name"));
8329								}
8330								r#name_property = Some({
8331									struct DeserializeWith(Vec<NameProperty>);
8332									impl<'de> Deserialize<'de> for DeserializeWith {
8333										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8334										where
8335											D: Deserializer<'de>,
8336										{
8337											Ok(DeserializeWith(serde_with::As::<
8338												serde_with::OneOrMany<serde_with::Same>,
8339											>::deserialize(deserializer)?))
8340										}
8341									}
8342									match map.next_value::<DeserializeWith>() {
8343										Ok(deserialize_with) => deserialize_with.0,
8344										Err(err) => {
8345											return Err(err);
8346										}
8347									}
8348								});
8349							}
8350							Field::PotentialAction => {
8351								if r#potential_action_property.is_some() {
8352									return Err(<A::Error as de::Error>::duplicate_field(
8353										"potentialAction",
8354									));
8355								}
8356								r#potential_action_property = Some({
8357									struct DeserializeWith(Vec<PotentialActionProperty>);
8358									impl<'de> Deserialize<'de> for DeserializeWith {
8359										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8360										where
8361											D: Deserializer<'de>,
8362										{
8363											Ok(DeserializeWith(serde_with::As::<
8364												serde_with::OneOrMany<serde_with::Same>,
8365											>::deserialize(deserializer)?))
8366										}
8367									}
8368									match map.next_value::<DeserializeWith>() {
8369										Ok(deserialize_with) => deserialize_with.0,
8370										Err(err) => {
8371											return Err(err);
8372										}
8373									}
8374								});
8375							}
8376							Field::SameAs => {
8377								if r#same_as_property.is_some() {
8378									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
8379								}
8380								r#same_as_property = Some({
8381									struct DeserializeWith(Vec<SameAsProperty>);
8382									impl<'de> Deserialize<'de> for DeserializeWith {
8383										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8384										where
8385											D: Deserializer<'de>,
8386										{
8387											Ok(DeserializeWith(serde_with::As::<
8388												serde_with::OneOrMany<serde_with::Same>,
8389											>::deserialize(deserializer)?))
8390										}
8391									}
8392									match map.next_value::<DeserializeWith>() {
8393										Ok(deserialize_with) => deserialize_with.0,
8394										Err(err) => {
8395											return Err(err);
8396										}
8397									}
8398								});
8399							}
8400							Field::SubjectOf => {
8401								if r#subject_of_property.is_some() {
8402									return Err(<A::Error as de::Error>::duplicate_field(
8403										"subjectOf",
8404									));
8405								}
8406								r#subject_of_property = Some({
8407									struct DeserializeWith(Vec<SubjectOfProperty>);
8408									impl<'de> Deserialize<'de> for DeserializeWith {
8409										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8410										where
8411											D: Deserializer<'de>,
8412										{
8413											Ok(DeserializeWith(serde_with::As::<
8414												serde_with::OneOrMany<serde_with::Same>,
8415											>::deserialize(deserializer)?))
8416										}
8417									}
8418									match map.next_value::<DeserializeWith>() {
8419										Ok(deserialize_with) => deserialize_with.0,
8420										Err(err) => {
8421											return Err(err);
8422										}
8423									}
8424								});
8425							}
8426							Field::Url => {
8427								if r#url_property.is_some() {
8428									return Err(<A::Error as de::Error>::duplicate_field("url"));
8429								}
8430								r#url_property = Some({
8431									struct DeserializeWith(Vec<UrlProperty>);
8432									impl<'de> Deserialize<'de> for DeserializeWith {
8433										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8434										where
8435											D: Deserializer<'de>,
8436										{
8437											Ok(DeserializeWith(serde_with::As::<
8438												serde_with::OneOrMany<serde_with::Same>,
8439											>::deserialize(deserializer)?))
8440										}
8441									}
8442									match map.next_value::<DeserializeWith>() {
8443										Ok(deserialize_with) => deserialize_with.0,
8444										Err(err) => {
8445											return Err(err);
8446										}
8447									}
8448								});
8449							}
8450							Field::Ignore => {
8451								let _ = map.next_value::<de::IgnoredAny>()?;
8452							}
8453						}
8454					}
8455					Ok(ReviewNewsArticle {
8456						r#article_body: r#article_body_property.unwrap_or_default(),
8457						r#article_section: r#article_section_property.unwrap_or_default(),
8458						r#backstory: r#backstory_property.unwrap_or_default(),
8459						r#page_end: r#page_end_property.unwrap_or_default(),
8460						r#page_start: r#page_start_property.unwrap_or_default(),
8461						r#pagination: r#pagination_property.unwrap_or_default(),
8462						r#speakable: r#speakable_property.unwrap_or_default(),
8463						r#word_count: r#word_count_property.unwrap_or_default(),
8464						r#about: r#about_property.unwrap_or_default(),
8465						r#abstract: r#abstract_property.unwrap_or_default(),
8466						r#access_mode: r#access_mode_property.unwrap_or_default(),
8467						r#access_mode_sufficient: r#access_mode_sufficient_property
8468							.unwrap_or_default(),
8469						r#accessibility_api: r#accessibility_api_property.unwrap_or_default(),
8470						r#accessibility_control: r#accessibility_control_property
8471							.unwrap_or_default(),
8472						r#accessibility_feature: r#accessibility_feature_property
8473							.unwrap_or_default(),
8474						r#accessibility_hazard: r#accessibility_hazard_property.unwrap_or_default(),
8475						r#accessibility_summary: r#accessibility_summary_property
8476							.unwrap_or_default(),
8477						r#accountable_person: r#accountable_person_property.unwrap_or_default(),
8478						r#acquire_license_page: r#acquire_license_page_property.unwrap_or_default(),
8479						r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
8480						r#alternative_headline: r#alternative_headline_property.unwrap_or_default(),
8481						r#archived_at: r#archived_at_property.unwrap_or_default(),
8482						r#assesses: r#assesses_property.unwrap_or_default(),
8483						r#associated_media: r#associated_media_property.unwrap_or_default(),
8484						r#audience: r#audience_property.unwrap_or_default(),
8485						r#audio: r#audio_property.unwrap_or_default(),
8486						r#author: r#author_property.unwrap_or_default(),
8487						r#award: r#award_property.unwrap_or_default(),
8488						r#awards: r#awards_property.unwrap_or_default(),
8489						r#character: r#character_property.unwrap_or_default(),
8490						r#citation: r#citation_property.unwrap_or_default(),
8491						r#comment: r#comment_property.unwrap_or_default(),
8492						r#comment_count: r#comment_count_property.unwrap_or_default(),
8493						r#conditions_of_access: r#conditions_of_access_property.unwrap_or_default(),
8494						r#content_location: r#content_location_property.unwrap_or_default(),
8495						r#content_rating: r#content_rating_property.unwrap_or_default(),
8496						r#content_reference_time: r#content_reference_time_property
8497							.unwrap_or_default(),
8498						r#contributor: r#contributor_property.unwrap_or_default(),
8499						r#copyright_holder: r#copyright_holder_property.unwrap_or_default(),
8500						r#copyright_notice: r#copyright_notice_property.unwrap_or_default(),
8501						r#copyright_year: r#copyright_year_property.unwrap_or_default(),
8502						r#correction: r#correction_property.unwrap_or_default(),
8503						r#country_of_origin: r#country_of_origin_property.unwrap_or_default(),
8504						r#creative_work_status: r#creative_work_status_property.unwrap_or_default(),
8505						r#creator: r#creator_property.unwrap_or_default(),
8506						r#credit_text: r#credit_text_property.unwrap_or_default(),
8507						r#date_created: r#date_created_property.unwrap_or_default(),
8508						r#date_modified: r#date_modified_property.unwrap_or_default(),
8509						r#date_published: r#date_published_property.unwrap_or_default(),
8510						r#discussion_url: r#discussion_url_property.unwrap_or_default(),
8511						r#edit_eidr: r#edit_eidr_property.unwrap_or_default(),
8512						r#editor: r#editor_property.unwrap_or_default(),
8513						r#educational_alignment: r#educational_alignment_property
8514							.unwrap_or_default(),
8515						r#educational_level: r#educational_level_property.unwrap_or_default(),
8516						r#educational_use: r#educational_use_property.unwrap_or_default(),
8517						r#encoding: r#encoding_property.unwrap_or_default(),
8518						r#encoding_format: r#encoding_format_property.unwrap_or_default(),
8519						r#encodings: r#encodings_property.unwrap_or_default(),
8520						r#example_of_work: r#example_of_work_property.unwrap_or_default(),
8521						r#expires: r#expires_property.unwrap_or_default(),
8522						r#file_format: r#file_format_property.unwrap_or_default(),
8523						r#funder: r#funder_property.unwrap_or_default(),
8524						r#funding: r#funding_property.unwrap_or_default(),
8525						r#genre: r#genre_property.unwrap_or_default(),
8526						r#has_part: r#has_part_property.unwrap_or_default(),
8527						r#headline: r#headline_property.unwrap_or_default(),
8528						r#in_language: r#in_language_property.unwrap_or_default(),
8529						r#interaction_statistic: r#interaction_statistic_property
8530							.unwrap_or_default(),
8531						r#interactivity_type: r#interactivity_type_property.unwrap_or_default(),
8532						r#interpreted_as_claim: r#interpreted_as_claim_property.unwrap_or_default(),
8533						r#is_accessible_for_free: r#is_accessible_for_free_property
8534							.unwrap_or_default(),
8535						r#is_based_on: r#is_based_on_property.unwrap_or_default(),
8536						r#is_based_on_url: r#is_based_on_url_property.unwrap_or_default(),
8537						r#is_family_friendly: r#is_family_friendly_property.unwrap_or_default(),
8538						r#is_part_of: r#is_part_of_property.unwrap_or_default(),
8539						r#keywords: r#keywords_property.unwrap_or_default(),
8540						r#learning_resource_type: r#learning_resource_type_property
8541							.unwrap_or_default(),
8542						r#license: r#license_property.unwrap_or_default(),
8543						r#location_created: r#location_created_property.unwrap_or_default(),
8544						r#main_entity: r#main_entity_property.unwrap_or_default(),
8545						r#maintainer: r#maintainer_property.unwrap_or_default(),
8546						r#material: r#material_property.unwrap_or_default(),
8547						r#material_extent: r#material_extent_property.unwrap_or_default(),
8548						r#mentions: r#mentions_property.unwrap_or_default(),
8549						r#offers: r#offers_property.unwrap_or_default(),
8550						r#pattern: r#pattern_property.unwrap_or_default(),
8551						r#position: r#position_property.unwrap_or_default(),
8552						r#producer: r#producer_property.unwrap_or_default(),
8553						r#provider: r#provider_property.unwrap_or_default(),
8554						r#publication: r#publication_property.unwrap_or_default(),
8555						r#publisher: r#publisher_property.unwrap_or_default(),
8556						r#publisher_imprint: r#publisher_imprint_property.unwrap_or_default(),
8557						r#publishing_principles: r#publishing_principles_property
8558							.unwrap_or_default(),
8559						r#recorded_at: r#recorded_at_property.unwrap_or_default(),
8560						r#released_event: r#released_event_property.unwrap_or_default(),
8561						r#review: r#review_property.unwrap_or_default(),
8562						r#reviews: r#reviews_property.unwrap_or_default(),
8563						r#schema_version: r#schema_version_property.unwrap_or_default(),
8564						r#sd_date_published: r#sd_date_published_property.unwrap_or_default(),
8565						r#sd_license: r#sd_license_property.unwrap_or_default(),
8566						r#sd_publisher: r#sd_publisher_property.unwrap_or_default(),
8567						r#size: r#size_property.unwrap_or_default(),
8568						r#source_organization: r#source_organization_property.unwrap_or_default(),
8569						r#spatial: r#spatial_property.unwrap_or_default(),
8570						r#spatial_coverage: r#spatial_coverage_property.unwrap_or_default(),
8571						r#sponsor: r#sponsor_property.unwrap_or_default(),
8572						r#teaches: r#teaches_property.unwrap_or_default(),
8573						r#temporal: r#temporal_property.unwrap_or_default(),
8574						r#temporal_coverage: r#temporal_coverage_property.unwrap_or_default(),
8575						r#text: r#text_property.unwrap_or_default(),
8576						r#thumbnail: r#thumbnail_property.unwrap_or_default(),
8577						r#thumbnail_url: r#thumbnail_url_property.unwrap_or_default(),
8578						r#time_required: r#time_required_property.unwrap_or_default(),
8579						r#translation_of_work: r#translation_of_work_property.unwrap_or_default(),
8580						r#translator: r#translator_property.unwrap_or_default(),
8581						r#typical_age_range: r#typical_age_range_property.unwrap_or_default(),
8582						r#usage_info: r#usage_info_property.unwrap_or_default(),
8583						r#version: r#version_property.unwrap_or_default(),
8584						r#video: r#video_property.unwrap_or_default(),
8585						r#work_example: r#work_example_property.unwrap_or_default(),
8586						r#work_translation: r#work_translation_property.unwrap_or_default(),
8587						r#dateline: r#dateline_property.unwrap_or_default(),
8588						r#print_column: r#print_column_property.unwrap_or_default(),
8589						r#print_edition: r#print_edition_property.unwrap_or_default(),
8590						r#print_page: r#print_page_property.unwrap_or_default(),
8591						r#print_section: r#print_section_property.unwrap_or_default(),
8592						r#associated_claim_review: r#associated_claim_review_property
8593							.unwrap_or_default(),
8594						r#associated_media_review: r#associated_media_review_property
8595							.unwrap_or_default(),
8596						r#associated_review: r#associated_review_property.unwrap_or_default(),
8597						r#item_reviewed: r#item_reviewed_property.unwrap_or_default(),
8598						r#negative_notes: r#negative_notes_property.unwrap_or_default(),
8599						r#positive_notes: r#positive_notes_property.unwrap_or_default(),
8600						r#review_aspect: r#review_aspect_property.unwrap_or_default(),
8601						r#review_body: r#review_body_property.unwrap_or_default(),
8602						r#review_rating: r#review_rating_property.unwrap_or_default(),
8603						r#additional_type: r#additional_type_property.unwrap_or_default(),
8604						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
8605						r#description: r#description_property.unwrap_or_default(),
8606						r#disambiguating_description: r#disambiguating_description_property
8607							.unwrap_or_default(),
8608						r#identifier: r#identifier_property.unwrap_or_default(),
8609						r#image: r#image_property.unwrap_or_default(),
8610						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
8611						r#name: r#name_property.unwrap_or_default(),
8612						r#potential_action: r#potential_action_property.unwrap_or_default(),
8613						r#same_as: r#same_as_property.unwrap_or_default(),
8614						r#subject_of: r#subject_of_property.unwrap_or_default(),
8615						r#url: r#url_property.unwrap_or_default(),
8616					})
8617				}
8618			}
8619			const FIELDS: &[&str] = &[
8620				"articleBody",
8621				"articleSection",
8622				"backstory",
8623				"pageEnd",
8624				"pageStart",
8625				"pagination",
8626				"speakable",
8627				"wordCount",
8628				"about",
8629				"abstract",
8630				"accessMode",
8631				"accessModeSufficient",
8632				"accessibilityAPI",
8633				"accessibilityControl",
8634				"accessibilityFeature",
8635				"accessibilityHazard",
8636				"accessibilitySummary",
8637				"accountablePerson",
8638				"acquireLicensePage",
8639				"aggregateRating",
8640				"alternativeHeadline",
8641				"archivedAt",
8642				"assesses",
8643				"associatedMedia",
8644				"audience",
8645				"audio",
8646				"author",
8647				"award",
8648				"awards",
8649				"character",
8650				"citation",
8651				"comment",
8652				"commentCount",
8653				"conditionsOfAccess",
8654				"contentLocation",
8655				"contentRating",
8656				"contentReferenceTime",
8657				"contributor",
8658				"copyrightHolder",
8659				"copyrightNotice",
8660				"copyrightYear",
8661				"correction",
8662				"countryOfOrigin",
8663				"creativeWorkStatus",
8664				"creator",
8665				"creditText",
8666				"dateCreated",
8667				"dateModified",
8668				"datePublished",
8669				"discussionUrl",
8670				"editEIDR",
8671				"editor",
8672				"educationalAlignment",
8673				"educationalLevel",
8674				"educationalUse",
8675				"encoding",
8676				"encodingFormat",
8677				"encodings",
8678				"exampleOfWork",
8679				"expires",
8680				"fileFormat",
8681				"funder",
8682				"funding",
8683				"genre",
8684				"hasPart",
8685				"headline",
8686				"inLanguage",
8687				"interactionStatistic",
8688				"interactivityType",
8689				"interpretedAsClaim",
8690				"isAccessibleForFree",
8691				"isBasedOn",
8692				"isBasedOnUrl",
8693				"isFamilyFriendly",
8694				"isPartOf",
8695				"keywords",
8696				"learningResourceType",
8697				"license",
8698				"locationCreated",
8699				"mainEntity",
8700				"maintainer",
8701				"material",
8702				"materialExtent",
8703				"mentions",
8704				"offers",
8705				"pattern",
8706				"position",
8707				"producer",
8708				"provider",
8709				"publication",
8710				"publisher",
8711				"publisherImprint",
8712				"publishingPrinciples",
8713				"recordedAt",
8714				"releasedEvent",
8715				"review",
8716				"reviews",
8717				"schemaVersion",
8718				"sdDatePublished",
8719				"sdLicense",
8720				"sdPublisher",
8721				"size",
8722				"sourceOrganization",
8723				"spatial",
8724				"spatialCoverage",
8725				"sponsor",
8726				"teaches",
8727				"temporal",
8728				"temporalCoverage",
8729				"text",
8730				"thumbnail",
8731				"thumbnailUrl",
8732				"timeRequired",
8733				"translationOfWork",
8734				"translator",
8735				"typicalAgeRange",
8736				"usageInfo",
8737				"version",
8738				"video",
8739				"workExample",
8740				"workTranslation",
8741				"dateline",
8742				"printColumn",
8743				"printEdition",
8744				"printPage",
8745				"printSection",
8746				"associatedClaimReview",
8747				"associatedMediaReview",
8748				"associatedReview",
8749				"itemReviewed",
8750				"negativeNotes",
8751				"positiveNotes",
8752				"reviewAspect",
8753				"reviewBody",
8754				"reviewRating",
8755				"additionalType",
8756				"alternateName",
8757				"description",
8758				"disambiguatingDescription",
8759				"identifier",
8760				"image",
8761				"mainEntityOfPage",
8762				"name",
8763				"potentialAction",
8764				"sameAs",
8765				"subjectOf",
8766				"url",
8767			];
8768			deserializer.deserialize_struct("ReviewNewsArticle", FIELDS, ClassVisitor)
8769		}
8770	}
8771}
schema_org_types/schemas/classes/review_news_article.rs

schema_org_types/schemas/classes/
review_news_article.rs
