schema_org_types/schemas/classes/
correction_comment.rs

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

schema_org_types/schemas/classes/
correction_comment.rs
