schema_org_types/schemas/classes/
tv_season.rs

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