schema_org_types/schemas/classes/
quiz.rs

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

schema_org_types/schemas/classes/
quiz.rs
