schema_org_types/schemas/classes/
creative_work.rs

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

schema_org_types/schemas/classes/
creative_work.rs
