schema_org_types/schemas/classes/
data_download.rs

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

schema_org_types/schemas/classes/
data_download.rs
