schema_org_types/schemas/classes/
complete_data_feed.rs

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

schema_org_types/schemas/classes/
complete_data_feed.rs
