schema_org_types/schemas/classes/
movie_series.rs

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

schema_org_types/schemas/classes/
movie_series.rs
