schema_org_types/schemas/classes/
book_series.rs

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

schema_org_types/schemas/classes/
book_series.rs
