schema_org_types/schemas/classes/
publication_volume.rs

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

schema_org_types/schemas/classes/
publication_volume.rs
