schema_org_types/schemas/classes/
menu.rs

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

schema_org_types/schemas/classes/
menu.rs
