schema_org_types/schemas/classes/
visual_artwork.rs

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

schema_org_types/schemas/classes/
visual_artwork.rs
