schema_org_types/schemas/classes/
how_to_section.rs

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

schema_org_types/schemas/classes/
how_to_section.rs
