schema_org_types/schemas/classes/
cover_art.rs

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

schema_org_types/schemas/classes/
cover_art.rs
