schema_org_types/schemas/classes/
menu_section.rs

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

schema_org_types/schemas/classes/
menu_section.rs
