schema_org_types/schemas/classes/
article.rs

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

schema_org_types/schemas/classes/
article.rs
