schema_org_types/schemas/classes/
guide.rs

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

schema_org_types/schemas/classes/
guide.rs
