schema_org_types/schemas/classes/
image_gallery.rs

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

schema_org_types/schemas/classes/
image_gallery.rs
