schema_org_types/schemas/classes/
advertiser_content_article.rs

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

schema_org_types/schemas/classes/
advertiser_content_article.rs
