schema_org_types/schemas/classes/
live_blog_posting.rs

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

schema_org_types/schemas/classes/
live_blog_posting.rs
