schema_org_types/schemas/classes/
image_object.rs

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

schema_org_types/schemas/classes/
image_object.rs
