schema_org_types/schemas/classes/
exercise_plan.rs

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

schema_org_types/schemas/classes/
exercise_plan.rs
