schema_org_types/schemas/classes/
wp_ad_block.rs

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

schema_org_types/schemas/classes/
wp_ad_block.rs
