schema_org_types/schemas/classes/
podcast_series.rs

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

schema_org_types/schemas/classes/
podcast_series.rs
