schema_org_types/schemas/classes/
podcast_episode.rs

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

schema_org_types/schemas/classes/
podcast_episode.rs
