schema_org_types/schemas/classes/
presentation_digital_document.rs

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

schema_org_types/schemas/classes/
presentation_digital_document.rs
