schema_org_types/schemas/classes/
data_catalog.rs

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

schema_org_types/schemas/classes/
data_catalog.rs
