schema_org_types/schemas/classes/
site_navigation_element.rs

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

schema_org_types/schemas/classes/
site_navigation_element.rs
