schema_org_types/schemas/classes/
web_site.rs

1use super::*;
2/// <https://schema.org/WebSite>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct WebSite {
6	/// <https://schema.org/issn>
7	pub r#issn: Vec<IssnProperty>,
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/WebSite>.
265pub trait WebSiteTrait {
266	/// Get <https://schema.org/issn> from [`Self`] as borrowed slice.
267	fn get_issn(&self) -> &[IssnProperty];
268	/// Take <https://schema.org/issn> from [`Self`] as owned vector.
269	fn take_issn(&mut self) -> Vec<IssnProperty>;
270}
271impl WebSiteTrait for WebSite {
272	fn get_issn(&self) -> &[IssnProperty] {
273		self.r#issn.as_slice()
274	}
275	fn take_issn(&mut self) -> Vec<IssnProperty> {
276		std::mem::take(&mut self.r#issn)
277	}
278}
279impl CreativeWorkTrait for WebSite {
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 WebSite {
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 WebSite {
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#issn) 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, "WebSite", len)?;
1178			if !Vec::is_empty(&self.r#issn) {
1179				serialize_struct.serialize_field("issn", {
1180					struct SerializeWith<'a>(&'a Vec<IssnProperty>);
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#issn)
1192				})?;
1193			} else {
1194				serialize_struct.skip_field("issn")?;
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 WebSite {
3450		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3451		where
3452			D: Deserializer<'de>,
3453		{
3454			enum Field {
3455				Issn,
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						"issn" => Ok(Field::Issn),
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"issn" => Ok(Field::Issn),
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 = WebSite;
3874				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
3875					formatter.write_str("schema.org schema WebSite")
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#issn_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::Issn => {
4010								if r#issn_property.is_some() {
4011									return Err(<A::Error as de::Error>::duplicate_field("issn"));
4012								}
4013								r#issn_property = Some({
4014									struct DeserializeWith(Vec<IssnProperty>);
4015									impl<'de> Deserialize<'de> for DeserializeWith {
4016										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4017										where
4018											D: Deserializer<'de>,
4019										{
4020											Ok(DeserializeWith(serde_with::As::<
4021												serde_with::OneOrMany<serde_with::Same>,
4022											>::deserialize(deserializer)?))
4023										}
4024									}
4025									match map.next_value::<DeserializeWith>() {
4026										Ok(deserialize_with) => deserialize_with.0,
4027										Err(err) => {
4028											return Err(err);
4029										}
4030									}
4031								});
4032							}
4033							Field::About => {
4034								if r#about_property.is_some() {
4035									return Err(<A::Error as de::Error>::duplicate_field("about"));
4036								}
4037								r#about_property = Some({
4038									struct DeserializeWith(Vec<AboutProperty>);
4039									impl<'de> Deserialize<'de> for DeserializeWith {
4040										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4041										where
4042											D: Deserializer<'de>,
4043										{
4044											Ok(DeserializeWith(serde_with::As::<
4045												serde_with::OneOrMany<serde_with::Same>,
4046											>::deserialize(deserializer)?))
4047										}
4048									}
4049									match map.next_value::<DeserializeWith>() {
4050										Ok(deserialize_with) => deserialize_with.0,
4051										Err(err) => {
4052											return Err(err);
4053										}
4054									}
4055								});
4056							}
4057							Field::Abstract => {
4058								if r#abstract_property.is_some() {
4059									return Err(<A::Error as de::Error>::duplicate_field(
4060										"abstract",
4061									));
4062								}
4063								r#abstract_property = Some({
4064									struct DeserializeWith(Vec<AbstractProperty>);
4065									impl<'de> Deserialize<'de> for DeserializeWith {
4066										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4067										where
4068											D: Deserializer<'de>,
4069										{
4070											Ok(DeserializeWith(serde_with::As::<
4071												serde_with::OneOrMany<serde_with::Same>,
4072											>::deserialize(deserializer)?))
4073										}
4074									}
4075									match map.next_value::<DeserializeWith>() {
4076										Ok(deserialize_with) => deserialize_with.0,
4077										Err(err) => {
4078											return Err(err);
4079										}
4080									}
4081								});
4082							}
4083							Field::AccessMode => {
4084								if r#access_mode_property.is_some() {
4085									return Err(<A::Error as de::Error>::duplicate_field(
4086										"accessMode",
4087									));
4088								}
4089								r#access_mode_property = Some({
4090									struct DeserializeWith(Vec<AccessModeProperty>);
4091									impl<'de> Deserialize<'de> for DeserializeWith {
4092										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4093										where
4094											D: Deserializer<'de>,
4095										{
4096											Ok(DeserializeWith(serde_with::As::<
4097												serde_with::OneOrMany<serde_with::Same>,
4098											>::deserialize(deserializer)?))
4099										}
4100									}
4101									match map.next_value::<DeserializeWith>() {
4102										Ok(deserialize_with) => deserialize_with.0,
4103										Err(err) => {
4104											return Err(err);
4105										}
4106									}
4107								});
4108							}
4109							Field::AccessModeSufficient => {
4110								if r#access_mode_sufficient_property.is_some() {
4111									return Err(<A::Error as de::Error>::duplicate_field(
4112										"accessModeSufficient",
4113									));
4114								}
4115								r#access_mode_sufficient_property = Some({
4116									struct DeserializeWith(Vec<AccessModeSufficientProperty>);
4117									impl<'de> Deserialize<'de> for DeserializeWith {
4118										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4119										where
4120											D: Deserializer<'de>,
4121										{
4122											Ok(DeserializeWith(serde_with::As::<
4123												serde_with::OneOrMany<serde_with::Same>,
4124											>::deserialize(deserializer)?))
4125										}
4126									}
4127									match map.next_value::<DeserializeWith>() {
4128										Ok(deserialize_with) => deserialize_with.0,
4129										Err(err) => {
4130											return Err(err);
4131										}
4132									}
4133								});
4134							}
4135							Field::AccessibilityApi => {
4136								if r#accessibility_api_property.is_some() {
4137									return Err(<A::Error as de::Error>::duplicate_field(
4138										"accessibilityAPI",
4139									));
4140								}
4141								r#accessibility_api_property = Some({
4142									struct DeserializeWith(Vec<AccessibilityApiProperty>);
4143									impl<'de> Deserialize<'de> for DeserializeWith {
4144										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4145										where
4146											D: Deserializer<'de>,
4147										{
4148											Ok(DeserializeWith(serde_with::As::<
4149												serde_with::OneOrMany<serde_with::Same>,
4150											>::deserialize(deserializer)?))
4151										}
4152									}
4153									match map.next_value::<DeserializeWith>() {
4154										Ok(deserialize_with) => deserialize_with.0,
4155										Err(err) => {
4156											return Err(err);
4157										}
4158									}
4159								});
4160							}
4161							Field::AccessibilityControl => {
4162								if r#accessibility_control_property.is_some() {
4163									return Err(<A::Error as de::Error>::duplicate_field(
4164										"accessibilityControl",
4165									));
4166								}
4167								r#accessibility_control_property = Some({
4168									struct DeserializeWith(Vec<AccessibilityControlProperty>);
4169									impl<'de> Deserialize<'de> for DeserializeWith {
4170										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4171										where
4172											D: Deserializer<'de>,
4173										{
4174											Ok(DeserializeWith(serde_with::As::<
4175												serde_with::OneOrMany<serde_with::Same>,
4176											>::deserialize(deserializer)?))
4177										}
4178									}
4179									match map.next_value::<DeserializeWith>() {
4180										Ok(deserialize_with) => deserialize_with.0,
4181										Err(err) => {
4182											return Err(err);
4183										}
4184									}
4185								});
4186							}
4187							Field::AccessibilityFeature => {
4188								if r#accessibility_feature_property.is_some() {
4189									return Err(<A::Error as de::Error>::duplicate_field(
4190										"accessibilityFeature",
4191									));
4192								}
4193								r#accessibility_feature_property = Some({
4194									struct DeserializeWith(Vec<AccessibilityFeatureProperty>);
4195									impl<'de> Deserialize<'de> for DeserializeWith {
4196										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4197										where
4198											D: Deserializer<'de>,
4199										{
4200											Ok(DeserializeWith(serde_with::As::<
4201												serde_with::OneOrMany<serde_with::Same>,
4202											>::deserialize(deserializer)?))
4203										}
4204									}
4205									match map.next_value::<DeserializeWith>() {
4206										Ok(deserialize_with) => deserialize_with.0,
4207										Err(err) => {
4208											return Err(err);
4209										}
4210									}
4211								});
4212							}
4213							Field::AccessibilityHazard => {
4214								if r#accessibility_hazard_property.is_some() {
4215									return Err(<A::Error as de::Error>::duplicate_field(
4216										"accessibilityHazard",
4217									));
4218								}
4219								r#accessibility_hazard_property = Some({
4220									struct DeserializeWith(Vec<AccessibilityHazardProperty>);
4221									impl<'de> Deserialize<'de> for DeserializeWith {
4222										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4223										where
4224											D: Deserializer<'de>,
4225										{
4226											Ok(DeserializeWith(serde_with::As::<
4227												serde_with::OneOrMany<serde_with::Same>,
4228											>::deserialize(deserializer)?))
4229										}
4230									}
4231									match map.next_value::<DeserializeWith>() {
4232										Ok(deserialize_with) => deserialize_with.0,
4233										Err(err) => {
4234											return Err(err);
4235										}
4236									}
4237								});
4238							}
4239							Field::AccessibilitySummary => {
4240								if r#accessibility_summary_property.is_some() {
4241									return Err(<A::Error as de::Error>::duplicate_field(
4242										"accessibilitySummary",
4243									));
4244								}
4245								r#accessibility_summary_property = Some({
4246									struct DeserializeWith(Vec<AccessibilitySummaryProperty>);
4247									impl<'de> Deserialize<'de> for DeserializeWith {
4248										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4249										where
4250											D: Deserializer<'de>,
4251										{
4252											Ok(DeserializeWith(serde_with::As::<
4253												serde_with::OneOrMany<serde_with::Same>,
4254											>::deserialize(deserializer)?))
4255										}
4256									}
4257									match map.next_value::<DeserializeWith>() {
4258										Ok(deserialize_with) => deserialize_with.0,
4259										Err(err) => {
4260											return Err(err);
4261										}
4262									}
4263								});
4264							}
4265							Field::AccountablePerson => {
4266								if r#accountable_person_property.is_some() {
4267									return Err(<A::Error as de::Error>::duplicate_field(
4268										"accountablePerson",
4269									));
4270								}
4271								r#accountable_person_property = Some({
4272									struct DeserializeWith(Vec<AccountablePersonProperty>);
4273									impl<'de> Deserialize<'de> for DeserializeWith {
4274										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4275										where
4276											D: Deserializer<'de>,
4277										{
4278											Ok(DeserializeWith(serde_with::As::<
4279												serde_with::OneOrMany<serde_with::Same>,
4280											>::deserialize(deserializer)?))
4281										}
4282									}
4283									match map.next_value::<DeserializeWith>() {
4284										Ok(deserialize_with) => deserialize_with.0,
4285										Err(err) => {
4286											return Err(err);
4287										}
4288									}
4289								});
4290							}
4291							Field::AcquireLicensePage => {
4292								if r#acquire_license_page_property.is_some() {
4293									return Err(<A::Error as de::Error>::duplicate_field(
4294										"acquireLicensePage",
4295									));
4296								}
4297								r#acquire_license_page_property = Some({
4298									struct DeserializeWith(Vec<AcquireLicensePageProperty>);
4299									impl<'de> Deserialize<'de> for DeserializeWith {
4300										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4301										where
4302											D: Deserializer<'de>,
4303										{
4304											Ok(DeserializeWith(serde_with::As::<
4305												serde_with::OneOrMany<serde_with::Same>,
4306											>::deserialize(deserializer)?))
4307										}
4308									}
4309									match map.next_value::<DeserializeWith>() {
4310										Ok(deserialize_with) => deserialize_with.0,
4311										Err(err) => {
4312											return Err(err);
4313										}
4314									}
4315								});
4316							}
4317							Field::AggregateRating => {
4318								if r#aggregate_rating_property.is_some() {
4319									return Err(<A::Error as de::Error>::duplicate_field(
4320										"aggregateRating",
4321									));
4322								}
4323								r#aggregate_rating_property = Some({
4324									struct DeserializeWith(Vec<AggregateRatingProperty>);
4325									impl<'de> Deserialize<'de> for DeserializeWith {
4326										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4327										where
4328											D: Deserializer<'de>,
4329										{
4330											Ok(DeserializeWith(serde_with::As::<
4331												serde_with::OneOrMany<serde_with::Same>,
4332											>::deserialize(deserializer)?))
4333										}
4334									}
4335									match map.next_value::<DeserializeWith>() {
4336										Ok(deserialize_with) => deserialize_with.0,
4337										Err(err) => {
4338											return Err(err);
4339										}
4340									}
4341								});
4342							}
4343							Field::AlternativeHeadline => {
4344								if r#alternative_headline_property.is_some() {
4345									return Err(<A::Error as de::Error>::duplicate_field(
4346										"alternativeHeadline",
4347									));
4348								}
4349								r#alternative_headline_property = Some({
4350									struct DeserializeWith(Vec<AlternativeHeadlineProperty>);
4351									impl<'de> Deserialize<'de> for DeserializeWith {
4352										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4353										where
4354											D: Deserializer<'de>,
4355										{
4356											Ok(DeserializeWith(serde_with::As::<
4357												serde_with::OneOrMany<serde_with::Same>,
4358											>::deserialize(deserializer)?))
4359										}
4360									}
4361									match map.next_value::<DeserializeWith>() {
4362										Ok(deserialize_with) => deserialize_with.0,
4363										Err(err) => {
4364											return Err(err);
4365										}
4366									}
4367								});
4368							}
4369							Field::ArchivedAt => {
4370								if r#archived_at_property.is_some() {
4371									return Err(<A::Error as de::Error>::duplicate_field(
4372										"archivedAt",
4373									));
4374								}
4375								r#archived_at_property = Some({
4376									struct DeserializeWith(Vec<ArchivedAtProperty>);
4377									impl<'de> Deserialize<'de> for DeserializeWith {
4378										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4379										where
4380											D: Deserializer<'de>,
4381										{
4382											Ok(DeserializeWith(serde_with::As::<
4383												serde_with::OneOrMany<serde_with::Same>,
4384											>::deserialize(deserializer)?))
4385										}
4386									}
4387									match map.next_value::<DeserializeWith>() {
4388										Ok(deserialize_with) => deserialize_with.0,
4389										Err(err) => {
4390											return Err(err);
4391										}
4392									}
4393								});
4394							}
4395							Field::Assesses => {
4396								if r#assesses_property.is_some() {
4397									return Err(<A::Error as de::Error>::duplicate_field(
4398										"assesses",
4399									));
4400								}
4401								r#assesses_property = Some({
4402									struct DeserializeWith(Vec<AssessesProperty>);
4403									impl<'de> Deserialize<'de> for DeserializeWith {
4404										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4405										where
4406											D: Deserializer<'de>,
4407										{
4408											Ok(DeserializeWith(serde_with::As::<
4409												serde_with::OneOrMany<serde_with::Same>,
4410											>::deserialize(deserializer)?))
4411										}
4412									}
4413									match map.next_value::<DeserializeWith>() {
4414										Ok(deserialize_with) => deserialize_with.0,
4415										Err(err) => {
4416											return Err(err);
4417										}
4418									}
4419								});
4420							}
4421							Field::AssociatedMedia => {
4422								if r#associated_media_property.is_some() {
4423									return Err(<A::Error as de::Error>::duplicate_field(
4424										"associatedMedia",
4425									));
4426								}
4427								r#associated_media_property = Some({
4428									struct DeserializeWith(Vec<AssociatedMediaProperty>);
4429									impl<'de> Deserialize<'de> for DeserializeWith {
4430										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4431										where
4432											D: Deserializer<'de>,
4433										{
4434											Ok(DeserializeWith(serde_with::As::<
4435												serde_with::OneOrMany<serde_with::Same>,
4436											>::deserialize(deserializer)?))
4437										}
4438									}
4439									match map.next_value::<DeserializeWith>() {
4440										Ok(deserialize_with) => deserialize_with.0,
4441										Err(err) => {
4442											return Err(err);
4443										}
4444									}
4445								});
4446							}
4447							Field::Audience => {
4448								if r#audience_property.is_some() {
4449									return Err(<A::Error as de::Error>::duplicate_field(
4450										"audience",
4451									));
4452								}
4453								r#audience_property = Some({
4454									struct DeserializeWith(Vec<AudienceProperty>);
4455									impl<'de> Deserialize<'de> for DeserializeWith {
4456										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4457										where
4458											D: Deserializer<'de>,
4459										{
4460											Ok(DeserializeWith(serde_with::As::<
4461												serde_with::OneOrMany<serde_with::Same>,
4462											>::deserialize(deserializer)?))
4463										}
4464									}
4465									match map.next_value::<DeserializeWith>() {
4466										Ok(deserialize_with) => deserialize_with.0,
4467										Err(err) => {
4468											return Err(err);
4469										}
4470									}
4471								});
4472							}
4473							Field::Audio => {
4474								if r#audio_property.is_some() {
4475									return Err(<A::Error as de::Error>::duplicate_field("audio"));
4476								}
4477								r#audio_property = Some({
4478									struct DeserializeWith(Vec<AudioProperty>);
4479									impl<'de> Deserialize<'de> for DeserializeWith {
4480										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4481										where
4482											D: Deserializer<'de>,
4483										{
4484											Ok(DeserializeWith(serde_with::As::<
4485												serde_with::OneOrMany<serde_with::Same>,
4486											>::deserialize(deserializer)?))
4487										}
4488									}
4489									match map.next_value::<DeserializeWith>() {
4490										Ok(deserialize_with) => deserialize_with.0,
4491										Err(err) => {
4492											return Err(err);
4493										}
4494									}
4495								});
4496							}
4497							Field::Author => {
4498								if r#author_property.is_some() {
4499									return Err(<A::Error as de::Error>::duplicate_field("author"));
4500								}
4501								r#author_property = Some({
4502									struct DeserializeWith(Vec<AuthorProperty>);
4503									impl<'de> Deserialize<'de> for DeserializeWith {
4504										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4505										where
4506											D: Deserializer<'de>,
4507										{
4508											Ok(DeserializeWith(serde_with::As::<
4509												serde_with::OneOrMany<serde_with::Same>,
4510											>::deserialize(deserializer)?))
4511										}
4512									}
4513									match map.next_value::<DeserializeWith>() {
4514										Ok(deserialize_with) => deserialize_with.0,
4515										Err(err) => {
4516											return Err(err);
4517										}
4518									}
4519								});
4520							}
4521							Field::Award => {
4522								if r#award_property.is_some() {
4523									return Err(<A::Error as de::Error>::duplicate_field("award"));
4524								}
4525								r#award_property = Some({
4526									struct DeserializeWith(Vec<AwardProperty>);
4527									impl<'de> Deserialize<'de> for DeserializeWith {
4528										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4529										where
4530											D: Deserializer<'de>,
4531										{
4532											Ok(DeserializeWith(serde_with::As::<
4533												serde_with::OneOrMany<serde_with::Same>,
4534											>::deserialize(deserializer)?))
4535										}
4536									}
4537									match map.next_value::<DeserializeWith>() {
4538										Ok(deserialize_with) => deserialize_with.0,
4539										Err(err) => {
4540											return Err(err);
4541										}
4542									}
4543								});
4544							}
4545							Field::Awards => {
4546								if r#awards_property.is_some() {
4547									return Err(<A::Error as de::Error>::duplicate_field("awards"));
4548								}
4549								r#awards_property = Some({
4550									struct DeserializeWith(Vec<AwardsProperty>);
4551									impl<'de> Deserialize<'de> for DeserializeWith {
4552										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4553										where
4554											D: Deserializer<'de>,
4555										{
4556											Ok(DeserializeWith(serde_with::As::<
4557												serde_with::OneOrMany<serde_with::Same>,
4558											>::deserialize(deserializer)?))
4559										}
4560									}
4561									match map.next_value::<DeserializeWith>() {
4562										Ok(deserialize_with) => deserialize_with.0,
4563										Err(err) => {
4564											return Err(err);
4565										}
4566									}
4567								});
4568							}
4569							Field::Character => {
4570								if r#character_property.is_some() {
4571									return Err(<A::Error as de::Error>::duplicate_field(
4572										"character",
4573									));
4574								}
4575								r#character_property = Some({
4576									struct DeserializeWith(Vec<CharacterProperty>);
4577									impl<'de> Deserialize<'de> for DeserializeWith {
4578										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4579										where
4580											D: Deserializer<'de>,
4581										{
4582											Ok(DeserializeWith(serde_with::As::<
4583												serde_with::OneOrMany<serde_with::Same>,
4584											>::deserialize(deserializer)?))
4585										}
4586									}
4587									match map.next_value::<DeserializeWith>() {
4588										Ok(deserialize_with) => deserialize_with.0,
4589										Err(err) => {
4590											return Err(err);
4591										}
4592									}
4593								});
4594							}
4595							Field::Citation => {
4596								if r#citation_property.is_some() {
4597									return Err(<A::Error as de::Error>::duplicate_field(
4598										"citation",
4599									));
4600								}
4601								r#citation_property = Some({
4602									struct DeserializeWith(Vec<CitationProperty>);
4603									impl<'de> Deserialize<'de> for DeserializeWith {
4604										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4605										where
4606											D: Deserializer<'de>,
4607										{
4608											Ok(DeserializeWith(serde_with::As::<
4609												serde_with::OneOrMany<serde_with::Same>,
4610											>::deserialize(deserializer)?))
4611										}
4612									}
4613									match map.next_value::<DeserializeWith>() {
4614										Ok(deserialize_with) => deserialize_with.0,
4615										Err(err) => {
4616											return Err(err);
4617										}
4618									}
4619								});
4620							}
4621							Field::Comment => {
4622								if r#comment_property.is_some() {
4623									return Err(<A::Error as de::Error>::duplicate_field(
4624										"comment",
4625									));
4626								}
4627								r#comment_property = Some({
4628									struct DeserializeWith(Vec<CommentProperty>);
4629									impl<'de> Deserialize<'de> for DeserializeWith {
4630										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4631										where
4632											D: Deserializer<'de>,
4633										{
4634											Ok(DeserializeWith(serde_with::As::<
4635												serde_with::OneOrMany<serde_with::Same>,
4636											>::deserialize(deserializer)?))
4637										}
4638									}
4639									match map.next_value::<DeserializeWith>() {
4640										Ok(deserialize_with) => deserialize_with.0,
4641										Err(err) => {
4642											return Err(err);
4643										}
4644									}
4645								});
4646							}
4647							Field::CommentCount => {
4648								if r#comment_count_property.is_some() {
4649									return Err(<A::Error as de::Error>::duplicate_field(
4650										"commentCount",
4651									));
4652								}
4653								r#comment_count_property = Some({
4654									struct DeserializeWith(Vec<CommentCountProperty>);
4655									impl<'de> Deserialize<'de> for DeserializeWith {
4656										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4657										where
4658											D: Deserializer<'de>,
4659										{
4660											Ok(DeserializeWith(serde_with::As::<
4661												serde_with::OneOrMany<serde_with::Same>,
4662											>::deserialize(deserializer)?))
4663										}
4664									}
4665									match map.next_value::<DeserializeWith>() {
4666										Ok(deserialize_with) => deserialize_with.0,
4667										Err(err) => {
4668											return Err(err);
4669										}
4670									}
4671								});
4672							}
4673							Field::ConditionsOfAccess => {
4674								if r#conditions_of_access_property.is_some() {
4675									return Err(<A::Error as de::Error>::duplicate_field(
4676										"conditionsOfAccess",
4677									));
4678								}
4679								r#conditions_of_access_property = Some({
4680									struct DeserializeWith(Vec<ConditionsOfAccessProperty>);
4681									impl<'de> Deserialize<'de> for DeserializeWith {
4682										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4683										where
4684											D: Deserializer<'de>,
4685										{
4686											Ok(DeserializeWith(serde_with::As::<
4687												serde_with::OneOrMany<serde_with::Same>,
4688											>::deserialize(deserializer)?))
4689										}
4690									}
4691									match map.next_value::<DeserializeWith>() {
4692										Ok(deserialize_with) => deserialize_with.0,
4693										Err(err) => {
4694											return Err(err);
4695										}
4696									}
4697								});
4698							}
4699							Field::ContentLocation => {
4700								if r#content_location_property.is_some() {
4701									return Err(<A::Error as de::Error>::duplicate_field(
4702										"contentLocation",
4703									));
4704								}
4705								r#content_location_property = Some({
4706									struct DeserializeWith(Vec<ContentLocationProperty>);
4707									impl<'de> Deserialize<'de> for DeserializeWith {
4708										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4709										where
4710											D: Deserializer<'de>,
4711										{
4712											Ok(DeserializeWith(serde_with::As::<
4713												serde_with::OneOrMany<serde_with::Same>,
4714											>::deserialize(deserializer)?))
4715										}
4716									}
4717									match map.next_value::<DeserializeWith>() {
4718										Ok(deserialize_with) => deserialize_with.0,
4719										Err(err) => {
4720											return Err(err);
4721										}
4722									}
4723								});
4724							}
4725							Field::ContentRating => {
4726								if r#content_rating_property.is_some() {
4727									return Err(<A::Error as de::Error>::duplicate_field(
4728										"contentRating",
4729									));
4730								}
4731								r#content_rating_property = Some({
4732									struct DeserializeWith(Vec<ContentRatingProperty>);
4733									impl<'de> Deserialize<'de> for DeserializeWith {
4734										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4735										where
4736											D: Deserializer<'de>,
4737										{
4738											Ok(DeserializeWith(serde_with::As::<
4739												serde_with::OneOrMany<serde_with::Same>,
4740											>::deserialize(deserializer)?))
4741										}
4742									}
4743									match map.next_value::<DeserializeWith>() {
4744										Ok(deserialize_with) => deserialize_with.0,
4745										Err(err) => {
4746											return Err(err);
4747										}
4748									}
4749								});
4750							}
4751							Field::ContentReferenceTime => {
4752								if r#content_reference_time_property.is_some() {
4753									return Err(<A::Error as de::Error>::duplicate_field(
4754										"contentReferenceTime",
4755									));
4756								}
4757								r#content_reference_time_property = Some({
4758									struct DeserializeWith(Vec<ContentReferenceTimeProperty>);
4759									impl<'de> Deserialize<'de> for DeserializeWith {
4760										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4761										where
4762											D: Deserializer<'de>,
4763										{
4764											Ok(DeserializeWith(serde_with::As::<
4765												serde_with::OneOrMany<serde_with::Same>,
4766											>::deserialize(deserializer)?))
4767										}
4768									}
4769									match map.next_value::<DeserializeWith>() {
4770										Ok(deserialize_with) => deserialize_with.0,
4771										Err(err) => {
4772											return Err(err);
4773										}
4774									}
4775								});
4776							}
4777							Field::Contributor => {
4778								if r#contributor_property.is_some() {
4779									return Err(<A::Error as de::Error>::duplicate_field(
4780										"contributor",
4781									));
4782								}
4783								r#contributor_property = Some({
4784									struct DeserializeWith(Vec<ContributorProperty>);
4785									impl<'de> Deserialize<'de> for DeserializeWith {
4786										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4787										where
4788											D: Deserializer<'de>,
4789										{
4790											Ok(DeserializeWith(serde_with::As::<
4791												serde_with::OneOrMany<serde_with::Same>,
4792											>::deserialize(deserializer)?))
4793										}
4794									}
4795									match map.next_value::<DeserializeWith>() {
4796										Ok(deserialize_with) => deserialize_with.0,
4797										Err(err) => {
4798											return Err(err);
4799										}
4800									}
4801								});
4802							}
4803							Field::CopyrightHolder => {
4804								if r#copyright_holder_property.is_some() {
4805									return Err(<A::Error as de::Error>::duplicate_field(
4806										"copyrightHolder",
4807									));
4808								}
4809								r#copyright_holder_property = Some({
4810									struct DeserializeWith(Vec<CopyrightHolderProperty>);
4811									impl<'de> Deserialize<'de> for DeserializeWith {
4812										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4813										where
4814											D: Deserializer<'de>,
4815										{
4816											Ok(DeserializeWith(serde_with::As::<
4817												serde_with::OneOrMany<serde_with::Same>,
4818											>::deserialize(deserializer)?))
4819										}
4820									}
4821									match map.next_value::<DeserializeWith>() {
4822										Ok(deserialize_with) => deserialize_with.0,
4823										Err(err) => {
4824											return Err(err);
4825										}
4826									}
4827								});
4828							}
4829							Field::CopyrightNotice => {
4830								if r#copyright_notice_property.is_some() {
4831									return Err(<A::Error as de::Error>::duplicate_field(
4832										"copyrightNotice",
4833									));
4834								}
4835								r#copyright_notice_property = Some({
4836									struct DeserializeWith(Vec<CopyrightNoticeProperty>);
4837									impl<'de> Deserialize<'de> for DeserializeWith {
4838										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4839										where
4840											D: Deserializer<'de>,
4841										{
4842											Ok(DeserializeWith(serde_with::As::<
4843												serde_with::OneOrMany<serde_with::Same>,
4844											>::deserialize(deserializer)?))
4845										}
4846									}
4847									match map.next_value::<DeserializeWith>() {
4848										Ok(deserialize_with) => deserialize_with.0,
4849										Err(err) => {
4850											return Err(err);
4851										}
4852									}
4853								});
4854							}
4855							Field::CopyrightYear => {
4856								if r#copyright_year_property.is_some() {
4857									return Err(<A::Error as de::Error>::duplicate_field(
4858										"copyrightYear",
4859									));
4860								}
4861								r#copyright_year_property = Some({
4862									struct DeserializeWith(Vec<CopyrightYearProperty>);
4863									impl<'de> Deserialize<'de> for DeserializeWith {
4864										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4865										where
4866											D: Deserializer<'de>,
4867										{
4868											Ok(DeserializeWith(serde_with::As::<
4869												serde_with::OneOrMany<serde_with::Same>,
4870											>::deserialize(deserializer)?))
4871										}
4872									}
4873									match map.next_value::<DeserializeWith>() {
4874										Ok(deserialize_with) => deserialize_with.0,
4875										Err(err) => {
4876											return Err(err);
4877										}
4878									}
4879								});
4880							}
4881							Field::Correction => {
4882								if r#correction_property.is_some() {
4883									return Err(<A::Error as de::Error>::duplicate_field(
4884										"correction",
4885									));
4886								}
4887								r#correction_property = Some({
4888									struct DeserializeWith(Vec<CorrectionProperty>);
4889									impl<'de> Deserialize<'de> for DeserializeWith {
4890										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4891										where
4892											D: Deserializer<'de>,
4893										{
4894											Ok(DeserializeWith(serde_with::As::<
4895												serde_with::OneOrMany<serde_with::Same>,
4896											>::deserialize(deserializer)?))
4897										}
4898									}
4899									match map.next_value::<DeserializeWith>() {
4900										Ok(deserialize_with) => deserialize_with.0,
4901										Err(err) => {
4902											return Err(err);
4903										}
4904									}
4905								});
4906							}
4907							Field::CountryOfOrigin => {
4908								if r#country_of_origin_property.is_some() {
4909									return Err(<A::Error as de::Error>::duplicate_field(
4910										"countryOfOrigin",
4911									));
4912								}
4913								r#country_of_origin_property = Some({
4914									struct DeserializeWith(Vec<CountryOfOriginProperty>);
4915									impl<'de> Deserialize<'de> for DeserializeWith {
4916										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4917										where
4918											D: Deserializer<'de>,
4919										{
4920											Ok(DeserializeWith(serde_with::As::<
4921												serde_with::OneOrMany<serde_with::Same>,
4922											>::deserialize(deserializer)?))
4923										}
4924									}
4925									match map.next_value::<DeserializeWith>() {
4926										Ok(deserialize_with) => deserialize_with.0,
4927										Err(err) => {
4928											return Err(err);
4929										}
4930									}
4931								});
4932							}
4933							Field::CreativeWorkStatus => {
4934								if r#creative_work_status_property.is_some() {
4935									return Err(<A::Error as de::Error>::duplicate_field(
4936										"creativeWorkStatus",
4937									));
4938								}
4939								r#creative_work_status_property = Some({
4940									struct DeserializeWith(Vec<CreativeWorkStatusProperty>);
4941									impl<'de> Deserialize<'de> for DeserializeWith {
4942										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4943										where
4944											D: Deserializer<'de>,
4945										{
4946											Ok(DeserializeWith(serde_with::As::<
4947												serde_with::OneOrMany<serde_with::Same>,
4948											>::deserialize(deserializer)?))
4949										}
4950									}
4951									match map.next_value::<DeserializeWith>() {
4952										Ok(deserialize_with) => deserialize_with.0,
4953										Err(err) => {
4954											return Err(err);
4955										}
4956									}
4957								});
4958							}
4959							Field::Creator => {
4960								if r#creator_property.is_some() {
4961									return Err(<A::Error as de::Error>::duplicate_field(
4962										"creator",
4963									));
4964								}
4965								r#creator_property = Some({
4966									struct DeserializeWith(Vec<CreatorProperty>);
4967									impl<'de> Deserialize<'de> for DeserializeWith {
4968										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4969										where
4970											D: Deserializer<'de>,
4971										{
4972											Ok(DeserializeWith(serde_with::As::<
4973												serde_with::OneOrMany<serde_with::Same>,
4974											>::deserialize(deserializer)?))
4975										}
4976									}
4977									match map.next_value::<DeserializeWith>() {
4978										Ok(deserialize_with) => deserialize_with.0,
4979										Err(err) => {
4980											return Err(err);
4981										}
4982									}
4983								});
4984							}
4985							Field::CreditText => {
4986								if r#credit_text_property.is_some() {
4987									return Err(<A::Error as de::Error>::duplicate_field(
4988										"creditText",
4989									));
4990								}
4991								r#credit_text_property = Some({
4992									struct DeserializeWith(Vec<CreditTextProperty>);
4993									impl<'de> Deserialize<'de> for DeserializeWith {
4994										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4995										where
4996											D: Deserializer<'de>,
4997										{
4998											Ok(DeserializeWith(serde_with::As::<
4999												serde_with::OneOrMany<serde_with::Same>,
5000											>::deserialize(deserializer)?))
5001										}
5002									}
5003									match map.next_value::<DeserializeWith>() {
5004										Ok(deserialize_with) => deserialize_with.0,
5005										Err(err) => {
5006											return Err(err);
5007										}
5008									}
5009								});
5010							}
5011							Field::DateCreated => {
5012								if r#date_created_property.is_some() {
5013									return Err(<A::Error as de::Error>::duplicate_field(
5014										"dateCreated",
5015									));
5016								}
5017								r#date_created_property = Some({
5018									struct DeserializeWith(Vec<DateCreatedProperty>);
5019									impl<'de> Deserialize<'de> for DeserializeWith {
5020										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5021										where
5022											D: Deserializer<'de>,
5023										{
5024											Ok(DeserializeWith(serde_with::As::<
5025												serde_with::OneOrMany<serde_with::Same>,
5026											>::deserialize(deserializer)?))
5027										}
5028									}
5029									match map.next_value::<DeserializeWith>() {
5030										Ok(deserialize_with) => deserialize_with.0,
5031										Err(err) => {
5032											return Err(err);
5033										}
5034									}
5035								});
5036							}
5037							Field::DateModified => {
5038								if r#date_modified_property.is_some() {
5039									return Err(<A::Error as de::Error>::duplicate_field(
5040										"dateModified",
5041									));
5042								}
5043								r#date_modified_property = Some({
5044									struct DeserializeWith(Vec<DateModifiedProperty>);
5045									impl<'de> Deserialize<'de> for DeserializeWith {
5046										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5047										where
5048											D: Deserializer<'de>,
5049										{
5050											Ok(DeserializeWith(serde_with::As::<
5051												serde_with::OneOrMany<serde_with::Same>,
5052											>::deserialize(deserializer)?))
5053										}
5054									}
5055									match map.next_value::<DeserializeWith>() {
5056										Ok(deserialize_with) => deserialize_with.0,
5057										Err(err) => {
5058											return Err(err);
5059										}
5060									}
5061								});
5062							}
5063							Field::DatePublished => {
5064								if r#date_published_property.is_some() {
5065									return Err(<A::Error as de::Error>::duplicate_field(
5066										"datePublished",
5067									));
5068								}
5069								r#date_published_property = Some({
5070									struct DeserializeWith(Vec<DatePublishedProperty>);
5071									impl<'de> Deserialize<'de> for DeserializeWith {
5072										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5073										where
5074											D: Deserializer<'de>,
5075										{
5076											Ok(DeserializeWith(serde_with::As::<
5077												serde_with::OneOrMany<serde_with::Same>,
5078											>::deserialize(deserializer)?))
5079										}
5080									}
5081									match map.next_value::<DeserializeWith>() {
5082										Ok(deserialize_with) => deserialize_with.0,
5083										Err(err) => {
5084											return Err(err);
5085										}
5086									}
5087								});
5088							}
5089							Field::DiscussionUrl => {
5090								if r#discussion_url_property.is_some() {
5091									return Err(<A::Error as de::Error>::duplicate_field(
5092										"discussionUrl",
5093									));
5094								}
5095								r#discussion_url_property = Some({
5096									struct DeserializeWith(Vec<DiscussionUrlProperty>);
5097									impl<'de> Deserialize<'de> for DeserializeWith {
5098										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5099										where
5100											D: Deserializer<'de>,
5101										{
5102											Ok(DeserializeWith(serde_with::As::<
5103												serde_with::OneOrMany<serde_with::Same>,
5104											>::deserialize(deserializer)?))
5105										}
5106									}
5107									match map.next_value::<DeserializeWith>() {
5108										Ok(deserialize_with) => deserialize_with.0,
5109										Err(err) => {
5110											return Err(err);
5111										}
5112									}
5113								});
5114							}
5115							Field::EditEidr => {
5116								if r#edit_eidr_property.is_some() {
5117									return Err(<A::Error as de::Error>::duplicate_field(
5118										"editEIDR",
5119									));
5120								}
5121								r#edit_eidr_property = Some({
5122									struct DeserializeWith(Vec<EditEidrProperty>);
5123									impl<'de> Deserialize<'de> for DeserializeWith {
5124										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5125										where
5126											D: Deserializer<'de>,
5127										{
5128											Ok(DeserializeWith(serde_with::As::<
5129												serde_with::OneOrMany<serde_with::Same>,
5130											>::deserialize(deserializer)?))
5131										}
5132									}
5133									match map.next_value::<DeserializeWith>() {
5134										Ok(deserialize_with) => deserialize_with.0,
5135										Err(err) => {
5136											return Err(err);
5137										}
5138									}
5139								});
5140							}
5141							Field::Editor => {
5142								if r#editor_property.is_some() {
5143									return Err(<A::Error as de::Error>::duplicate_field("editor"));
5144								}
5145								r#editor_property = Some({
5146									struct DeserializeWith(Vec<EditorProperty>);
5147									impl<'de> Deserialize<'de> for DeserializeWith {
5148										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5149										where
5150											D: Deserializer<'de>,
5151										{
5152											Ok(DeserializeWith(serde_with::As::<
5153												serde_with::OneOrMany<serde_with::Same>,
5154											>::deserialize(deserializer)?))
5155										}
5156									}
5157									match map.next_value::<DeserializeWith>() {
5158										Ok(deserialize_with) => deserialize_with.0,
5159										Err(err) => {
5160											return Err(err);
5161										}
5162									}
5163								});
5164							}
5165							Field::EducationalAlignment => {
5166								if r#educational_alignment_property.is_some() {
5167									return Err(<A::Error as de::Error>::duplicate_field(
5168										"educationalAlignment",
5169									));
5170								}
5171								r#educational_alignment_property = Some({
5172									struct DeserializeWith(Vec<EducationalAlignmentProperty>);
5173									impl<'de> Deserialize<'de> for DeserializeWith {
5174										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5175										where
5176											D: Deserializer<'de>,
5177										{
5178											Ok(DeserializeWith(serde_with::As::<
5179												serde_with::OneOrMany<serde_with::Same>,
5180											>::deserialize(deserializer)?))
5181										}
5182									}
5183									match map.next_value::<DeserializeWith>() {
5184										Ok(deserialize_with) => deserialize_with.0,
5185										Err(err) => {
5186											return Err(err);
5187										}
5188									}
5189								});
5190							}
5191							Field::EducationalLevel => {
5192								if r#educational_level_property.is_some() {
5193									return Err(<A::Error as de::Error>::duplicate_field(
5194										"educationalLevel",
5195									));
5196								}
5197								r#educational_level_property = Some({
5198									struct DeserializeWith(Vec<EducationalLevelProperty>);
5199									impl<'de> Deserialize<'de> for DeserializeWith {
5200										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5201										where
5202											D: Deserializer<'de>,
5203										{
5204											Ok(DeserializeWith(serde_with::As::<
5205												serde_with::OneOrMany<serde_with::Same>,
5206											>::deserialize(deserializer)?))
5207										}
5208									}
5209									match map.next_value::<DeserializeWith>() {
5210										Ok(deserialize_with) => deserialize_with.0,
5211										Err(err) => {
5212											return Err(err);
5213										}
5214									}
5215								});
5216							}
5217							Field::EducationalUse => {
5218								if r#educational_use_property.is_some() {
5219									return Err(<A::Error as de::Error>::duplicate_field(
5220										"educationalUse",
5221									));
5222								}
5223								r#educational_use_property = Some({
5224									struct DeserializeWith(Vec<EducationalUseProperty>);
5225									impl<'de> Deserialize<'de> for DeserializeWith {
5226										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5227										where
5228											D: Deserializer<'de>,
5229										{
5230											Ok(DeserializeWith(serde_with::As::<
5231												serde_with::OneOrMany<serde_with::Same>,
5232											>::deserialize(deserializer)?))
5233										}
5234									}
5235									match map.next_value::<DeserializeWith>() {
5236										Ok(deserialize_with) => deserialize_with.0,
5237										Err(err) => {
5238											return Err(err);
5239										}
5240									}
5241								});
5242							}
5243							Field::Encoding => {
5244								if r#encoding_property.is_some() {
5245									return Err(<A::Error as de::Error>::duplicate_field(
5246										"encoding",
5247									));
5248								}
5249								r#encoding_property = Some({
5250									struct DeserializeWith(Vec<EncodingProperty>);
5251									impl<'de> Deserialize<'de> for DeserializeWith {
5252										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5253										where
5254											D: Deserializer<'de>,
5255										{
5256											Ok(DeserializeWith(serde_with::As::<
5257												serde_with::OneOrMany<serde_with::Same>,
5258											>::deserialize(deserializer)?))
5259										}
5260									}
5261									match map.next_value::<DeserializeWith>() {
5262										Ok(deserialize_with) => deserialize_with.0,
5263										Err(err) => {
5264											return Err(err);
5265										}
5266									}
5267								});
5268							}
5269							Field::EncodingFormat => {
5270								if r#encoding_format_property.is_some() {
5271									return Err(<A::Error as de::Error>::duplicate_field(
5272										"encodingFormat",
5273									));
5274								}
5275								r#encoding_format_property = Some({
5276									struct DeserializeWith(Vec<EncodingFormatProperty>);
5277									impl<'de> Deserialize<'de> for DeserializeWith {
5278										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5279										where
5280											D: Deserializer<'de>,
5281										{
5282											Ok(DeserializeWith(serde_with::As::<
5283												serde_with::OneOrMany<serde_with::Same>,
5284											>::deserialize(deserializer)?))
5285										}
5286									}
5287									match map.next_value::<DeserializeWith>() {
5288										Ok(deserialize_with) => deserialize_with.0,
5289										Err(err) => {
5290											return Err(err);
5291										}
5292									}
5293								});
5294							}
5295							Field::Encodings => {
5296								if r#encodings_property.is_some() {
5297									return Err(<A::Error as de::Error>::duplicate_field(
5298										"encodings",
5299									));
5300								}
5301								r#encodings_property = Some({
5302									struct DeserializeWith(Vec<EncodingsProperty>);
5303									impl<'de> Deserialize<'de> for DeserializeWith {
5304										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5305										where
5306											D: Deserializer<'de>,
5307										{
5308											Ok(DeserializeWith(serde_with::As::<
5309												serde_with::OneOrMany<serde_with::Same>,
5310											>::deserialize(deserializer)?))
5311										}
5312									}
5313									match map.next_value::<DeserializeWith>() {
5314										Ok(deserialize_with) => deserialize_with.0,
5315										Err(err) => {
5316											return Err(err);
5317										}
5318									}
5319								});
5320							}
5321							Field::ExampleOfWork => {
5322								if r#example_of_work_property.is_some() {
5323									return Err(<A::Error as de::Error>::duplicate_field(
5324										"exampleOfWork",
5325									));
5326								}
5327								r#example_of_work_property = Some({
5328									struct DeserializeWith(Vec<ExampleOfWorkProperty>);
5329									impl<'de> Deserialize<'de> for DeserializeWith {
5330										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5331										where
5332											D: Deserializer<'de>,
5333										{
5334											Ok(DeserializeWith(serde_with::As::<
5335												serde_with::OneOrMany<serde_with::Same>,
5336											>::deserialize(deserializer)?))
5337										}
5338									}
5339									match map.next_value::<DeserializeWith>() {
5340										Ok(deserialize_with) => deserialize_with.0,
5341										Err(err) => {
5342											return Err(err);
5343										}
5344									}
5345								});
5346							}
5347							Field::Expires => {
5348								if r#expires_property.is_some() {
5349									return Err(<A::Error as de::Error>::duplicate_field(
5350										"expires",
5351									));
5352								}
5353								r#expires_property = Some({
5354									struct DeserializeWith(Vec<ExpiresProperty>);
5355									impl<'de> Deserialize<'de> for DeserializeWith {
5356										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5357										where
5358											D: Deserializer<'de>,
5359										{
5360											Ok(DeserializeWith(serde_with::As::<
5361												serde_with::OneOrMany<serde_with::Same>,
5362											>::deserialize(deserializer)?))
5363										}
5364									}
5365									match map.next_value::<DeserializeWith>() {
5366										Ok(deserialize_with) => deserialize_with.0,
5367										Err(err) => {
5368											return Err(err);
5369										}
5370									}
5371								});
5372							}
5373							Field::FileFormat => {
5374								if r#file_format_property.is_some() {
5375									return Err(<A::Error as de::Error>::duplicate_field(
5376										"fileFormat",
5377									));
5378								}
5379								r#file_format_property = Some({
5380									struct DeserializeWith(Vec<FileFormatProperty>);
5381									impl<'de> Deserialize<'de> for DeserializeWith {
5382										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5383										where
5384											D: Deserializer<'de>,
5385										{
5386											Ok(DeserializeWith(serde_with::As::<
5387												serde_with::OneOrMany<serde_with::Same>,
5388											>::deserialize(deserializer)?))
5389										}
5390									}
5391									match map.next_value::<DeserializeWith>() {
5392										Ok(deserialize_with) => deserialize_with.0,
5393										Err(err) => {
5394											return Err(err);
5395										}
5396									}
5397								});
5398							}
5399							Field::Funder => {
5400								if r#funder_property.is_some() {
5401									return Err(<A::Error as de::Error>::duplicate_field("funder"));
5402								}
5403								r#funder_property = Some({
5404									struct DeserializeWith(Vec<FunderProperty>);
5405									impl<'de> Deserialize<'de> for DeserializeWith {
5406										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5407										where
5408											D: Deserializer<'de>,
5409										{
5410											Ok(DeserializeWith(serde_with::As::<
5411												serde_with::OneOrMany<serde_with::Same>,
5412											>::deserialize(deserializer)?))
5413										}
5414									}
5415									match map.next_value::<DeserializeWith>() {
5416										Ok(deserialize_with) => deserialize_with.0,
5417										Err(err) => {
5418											return Err(err);
5419										}
5420									}
5421								});
5422							}
5423							Field::Funding => {
5424								if r#funding_property.is_some() {
5425									return Err(<A::Error as de::Error>::duplicate_field(
5426										"funding",
5427									));
5428								}
5429								r#funding_property = Some({
5430									struct DeserializeWith(Vec<FundingProperty>);
5431									impl<'de> Deserialize<'de> for DeserializeWith {
5432										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5433										where
5434											D: Deserializer<'de>,
5435										{
5436											Ok(DeserializeWith(serde_with::As::<
5437												serde_with::OneOrMany<serde_with::Same>,
5438											>::deserialize(deserializer)?))
5439										}
5440									}
5441									match map.next_value::<DeserializeWith>() {
5442										Ok(deserialize_with) => deserialize_with.0,
5443										Err(err) => {
5444											return Err(err);
5445										}
5446									}
5447								});
5448							}
5449							Field::Genre => {
5450								if r#genre_property.is_some() {
5451									return Err(<A::Error as de::Error>::duplicate_field("genre"));
5452								}
5453								r#genre_property = Some({
5454									struct DeserializeWith(Vec<GenreProperty>);
5455									impl<'de> Deserialize<'de> for DeserializeWith {
5456										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5457										where
5458											D: Deserializer<'de>,
5459										{
5460											Ok(DeserializeWith(serde_with::As::<
5461												serde_with::OneOrMany<serde_with::Same>,
5462											>::deserialize(deserializer)?))
5463										}
5464									}
5465									match map.next_value::<DeserializeWith>() {
5466										Ok(deserialize_with) => deserialize_with.0,
5467										Err(err) => {
5468											return Err(err);
5469										}
5470									}
5471								});
5472							}
5473							Field::HasPart => {
5474								if r#has_part_property.is_some() {
5475									return Err(<A::Error as de::Error>::duplicate_field(
5476										"hasPart",
5477									));
5478								}
5479								r#has_part_property = Some({
5480									struct DeserializeWith(Vec<HasPartProperty>);
5481									impl<'de> Deserialize<'de> for DeserializeWith {
5482										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5483										where
5484											D: Deserializer<'de>,
5485										{
5486											Ok(DeserializeWith(serde_with::As::<
5487												serde_with::OneOrMany<serde_with::Same>,
5488											>::deserialize(deserializer)?))
5489										}
5490									}
5491									match map.next_value::<DeserializeWith>() {
5492										Ok(deserialize_with) => deserialize_with.0,
5493										Err(err) => {
5494											return Err(err);
5495										}
5496									}
5497								});
5498							}
5499							Field::Headline => {
5500								if r#headline_property.is_some() {
5501									return Err(<A::Error as de::Error>::duplicate_field(
5502										"headline",
5503									));
5504								}
5505								r#headline_property = Some({
5506									struct DeserializeWith(Vec<HeadlineProperty>);
5507									impl<'de> Deserialize<'de> for DeserializeWith {
5508										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5509										where
5510											D: Deserializer<'de>,
5511										{
5512											Ok(DeserializeWith(serde_with::As::<
5513												serde_with::OneOrMany<serde_with::Same>,
5514											>::deserialize(deserializer)?))
5515										}
5516									}
5517									match map.next_value::<DeserializeWith>() {
5518										Ok(deserialize_with) => deserialize_with.0,
5519										Err(err) => {
5520											return Err(err);
5521										}
5522									}
5523								});
5524							}
5525							Field::InLanguage => {
5526								if r#in_language_property.is_some() {
5527									return Err(<A::Error as de::Error>::duplicate_field(
5528										"inLanguage",
5529									));
5530								}
5531								r#in_language_property = Some({
5532									struct DeserializeWith(Vec<InLanguageProperty>);
5533									impl<'de> Deserialize<'de> for DeserializeWith {
5534										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5535										where
5536											D: Deserializer<'de>,
5537										{
5538											Ok(DeserializeWith(serde_with::As::<
5539												serde_with::OneOrMany<serde_with::Same>,
5540											>::deserialize(deserializer)?))
5541										}
5542									}
5543									match map.next_value::<DeserializeWith>() {
5544										Ok(deserialize_with) => deserialize_with.0,
5545										Err(err) => {
5546											return Err(err);
5547										}
5548									}
5549								});
5550							}
5551							Field::InteractionStatistic => {
5552								if r#interaction_statistic_property.is_some() {
5553									return Err(<A::Error as de::Error>::duplicate_field(
5554										"interactionStatistic",
5555									));
5556								}
5557								r#interaction_statistic_property = Some({
5558									struct DeserializeWith(Vec<InteractionStatisticProperty>);
5559									impl<'de> Deserialize<'de> for DeserializeWith {
5560										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5561										where
5562											D: Deserializer<'de>,
5563										{
5564											Ok(DeserializeWith(serde_with::As::<
5565												serde_with::OneOrMany<serde_with::Same>,
5566											>::deserialize(deserializer)?))
5567										}
5568									}
5569									match map.next_value::<DeserializeWith>() {
5570										Ok(deserialize_with) => deserialize_with.0,
5571										Err(err) => {
5572											return Err(err);
5573										}
5574									}
5575								});
5576							}
5577							Field::InteractivityType => {
5578								if r#interactivity_type_property.is_some() {
5579									return Err(<A::Error as de::Error>::duplicate_field(
5580										"interactivityType",
5581									));
5582								}
5583								r#interactivity_type_property = Some({
5584									struct DeserializeWith(Vec<InteractivityTypeProperty>);
5585									impl<'de> Deserialize<'de> for DeserializeWith {
5586										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5587										where
5588											D: Deserializer<'de>,
5589										{
5590											Ok(DeserializeWith(serde_with::As::<
5591												serde_with::OneOrMany<serde_with::Same>,
5592											>::deserialize(deserializer)?))
5593										}
5594									}
5595									match map.next_value::<DeserializeWith>() {
5596										Ok(deserialize_with) => deserialize_with.0,
5597										Err(err) => {
5598											return Err(err);
5599										}
5600									}
5601								});
5602							}
5603							Field::InterpretedAsClaim => {
5604								if r#interpreted_as_claim_property.is_some() {
5605									return Err(<A::Error as de::Error>::duplicate_field(
5606										"interpretedAsClaim",
5607									));
5608								}
5609								r#interpreted_as_claim_property = Some({
5610									struct DeserializeWith(Vec<InterpretedAsClaimProperty>);
5611									impl<'de> Deserialize<'de> for DeserializeWith {
5612										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5613										where
5614											D: Deserializer<'de>,
5615										{
5616											Ok(DeserializeWith(serde_with::As::<
5617												serde_with::OneOrMany<serde_with::Same>,
5618											>::deserialize(deserializer)?))
5619										}
5620									}
5621									match map.next_value::<DeserializeWith>() {
5622										Ok(deserialize_with) => deserialize_with.0,
5623										Err(err) => {
5624											return Err(err);
5625										}
5626									}
5627								});
5628							}
5629							Field::IsAccessibleForFree => {
5630								if r#is_accessible_for_free_property.is_some() {
5631									return Err(<A::Error as de::Error>::duplicate_field(
5632										"isAccessibleForFree",
5633									));
5634								}
5635								r#is_accessible_for_free_property = Some({
5636									struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
5637									impl<'de> Deserialize<'de> for DeserializeWith {
5638										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5639										where
5640											D: Deserializer<'de>,
5641										{
5642											Ok(DeserializeWith(serde_with::As::<
5643												serde_with::OneOrMany<serde_with::Same>,
5644											>::deserialize(deserializer)?))
5645										}
5646									}
5647									match map.next_value::<DeserializeWith>() {
5648										Ok(deserialize_with) => deserialize_with.0,
5649										Err(err) => {
5650											return Err(err);
5651										}
5652									}
5653								});
5654							}
5655							Field::IsBasedOn => {
5656								if r#is_based_on_property.is_some() {
5657									return Err(<A::Error as de::Error>::duplicate_field(
5658										"isBasedOn",
5659									));
5660								}
5661								r#is_based_on_property = Some({
5662									struct DeserializeWith(Vec<IsBasedOnProperty>);
5663									impl<'de> Deserialize<'de> for DeserializeWith {
5664										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5665										where
5666											D: Deserializer<'de>,
5667										{
5668											Ok(DeserializeWith(serde_with::As::<
5669												serde_with::OneOrMany<serde_with::Same>,
5670											>::deserialize(deserializer)?))
5671										}
5672									}
5673									match map.next_value::<DeserializeWith>() {
5674										Ok(deserialize_with) => deserialize_with.0,
5675										Err(err) => {
5676											return Err(err);
5677										}
5678									}
5679								});
5680							}
5681							Field::IsBasedOnUrl => {
5682								if r#is_based_on_url_property.is_some() {
5683									return Err(<A::Error as de::Error>::duplicate_field(
5684										"isBasedOnUrl",
5685									));
5686								}
5687								r#is_based_on_url_property = Some({
5688									struct DeserializeWith(Vec<IsBasedOnUrlProperty>);
5689									impl<'de> Deserialize<'de> for DeserializeWith {
5690										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5691										where
5692											D: Deserializer<'de>,
5693										{
5694											Ok(DeserializeWith(serde_with::As::<
5695												serde_with::OneOrMany<serde_with::Same>,
5696											>::deserialize(deserializer)?))
5697										}
5698									}
5699									match map.next_value::<DeserializeWith>() {
5700										Ok(deserialize_with) => deserialize_with.0,
5701										Err(err) => {
5702											return Err(err);
5703										}
5704									}
5705								});
5706							}
5707							Field::IsFamilyFriendly => {
5708								if r#is_family_friendly_property.is_some() {
5709									return Err(<A::Error as de::Error>::duplicate_field(
5710										"isFamilyFriendly",
5711									));
5712								}
5713								r#is_family_friendly_property = Some({
5714									struct DeserializeWith(Vec<IsFamilyFriendlyProperty>);
5715									impl<'de> Deserialize<'de> for DeserializeWith {
5716										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5717										where
5718											D: Deserializer<'de>,
5719										{
5720											Ok(DeserializeWith(serde_with::As::<
5721												serde_with::OneOrMany<serde_with::Same>,
5722											>::deserialize(deserializer)?))
5723										}
5724									}
5725									match map.next_value::<DeserializeWith>() {
5726										Ok(deserialize_with) => deserialize_with.0,
5727										Err(err) => {
5728											return Err(err);
5729										}
5730									}
5731								});
5732							}
5733							Field::IsPartOf => {
5734								if r#is_part_of_property.is_some() {
5735									return Err(<A::Error as de::Error>::duplicate_field(
5736										"isPartOf",
5737									));
5738								}
5739								r#is_part_of_property = Some({
5740									struct DeserializeWith(Vec<IsPartOfProperty>);
5741									impl<'de> Deserialize<'de> for DeserializeWith {
5742										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5743										where
5744											D: Deserializer<'de>,
5745										{
5746											Ok(DeserializeWith(serde_with::As::<
5747												serde_with::OneOrMany<serde_with::Same>,
5748											>::deserialize(deserializer)?))
5749										}
5750									}
5751									match map.next_value::<DeserializeWith>() {
5752										Ok(deserialize_with) => deserialize_with.0,
5753										Err(err) => {
5754											return Err(err);
5755										}
5756									}
5757								});
5758							}
5759							Field::Keywords => {
5760								if r#keywords_property.is_some() {
5761									return Err(<A::Error as de::Error>::duplicate_field(
5762										"keywords",
5763									));
5764								}
5765								r#keywords_property = Some({
5766									struct DeserializeWith(Vec<KeywordsProperty>);
5767									impl<'de> Deserialize<'de> for DeserializeWith {
5768										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5769										where
5770											D: Deserializer<'de>,
5771										{
5772											Ok(DeserializeWith(serde_with::As::<
5773												serde_with::OneOrMany<serde_with::Same>,
5774											>::deserialize(deserializer)?))
5775										}
5776									}
5777									match map.next_value::<DeserializeWith>() {
5778										Ok(deserialize_with) => deserialize_with.0,
5779										Err(err) => {
5780											return Err(err);
5781										}
5782									}
5783								});
5784							}
5785							Field::LearningResourceType => {
5786								if r#learning_resource_type_property.is_some() {
5787									return Err(<A::Error as de::Error>::duplicate_field(
5788										"learningResourceType",
5789									));
5790								}
5791								r#learning_resource_type_property = Some({
5792									struct DeserializeWith(Vec<LearningResourceTypeProperty>);
5793									impl<'de> Deserialize<'de> for DeserializeWith {
5794										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5795										where
5796											D: Deserializer<'de>,
5797										{
5798											Ok(DeserializeWith(serde_with::As::<
5799												serde_with::OneOrMany<serde_with::Same>,
5800											>::deserialize(deserializer)?))
5801										}
5802									}
5803									match map.next_value::<DeserializeWith>() {
5804										Ok(deserialize_with) => deserialize_with.0,
5805										Err(err) => {
5806											return Err(err);
5807										}
5808									}
5809								});
5810							}
5811							Field::License => {
5812								if r#license_property.is_some() {
5813									return Err(<A::Error as de::Error>::duplicate_field(
5814										"license",
5815									));
5816								}
5817								r#license_property = Some({
5818									struct DeserializeWith(Vec<LicenseProperty>);
5819									impl<'de> Deserialize<'de> for DeserializeWith {
5820										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5821										where
5822											D: Deserializer<'de>,
5823										{
5824											Ok(DeserializeWith(serde_with::As::<
5825												serde_with::OneOrMany<serde_with::Same>,
5826											>::deserialize(deserializer)?))
5827										}
5828									}
5829									match map.next_value::<DeserializeWith>() {
5830										Ok(deserialize_with) => deserialize_with.0,
5831										Err(err) => {
5832											return Err(err);
5833										}
5834									}
5835								});
5836							}
5837							Field::LocationCreated => {
5838								if r#location_created_property.is_some() {
5839									return Err(<A::Error as de::Error>::duplicate_field(
5840										"locationCreated",
5841									));
5842								}
5843								r#location_created_property = Some({
5844									struct DeserializeWith(Vec<LocationCreatedProperty>);
5845									impl<'de> Deserialize<'de> for DeserializeWith {
5846										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5847										where
5848											D: Deserializer<'de>,
5849										{
5850											Ok(DeserializeWith(serde_with::As::<
5851												serde_with::OneOrMany<serde_with::Same>,
5852											>::deserialize(deserializer)?))
5853										}
5854									}
5855									match map.next_value::<DeserializeWith>() {
5856										Ok(deserialize_with) => deserialize_with.0,
5857										Err(err) => {
5858											return Err(err);
5859										}
5860									}
5861								});
5862							}
5863							Field::MainEntity => {
5864								if r#main_entity_property.is_some() {
5865									return Err(<A::Error as de::Error>::duplicate_field(
5866										"mainEntity",
5867									));
5868								}
5869								r#main_entity_property = Some({
5870									struct DeserializeWith(Vec<MainEntityProperty>);
5871									impl<'de> Deserialize<'de> for DeserializeWith {
5872										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5873										where
5874											D: Deserializer<'de>,
5875										{
5876											Ok(DeserializeWith(serde_with::As::<
5877												serde_with::OneOrMany<serde_with::Same>,
5878											>::deserialize(deserializer)?))
5879										}
5880									}
5881									match map.next_value::<DeserializeWith>() {
5882										Ok(deserialize_with) => deserialize_with.0,
5883										Err(err) => {
5884											return Err(err);
5885										}
5886									}
5887								});
5888							}
5889							Field::Maintainer => {
5890								if r#maintainer_property.is_some() {
5891									return Err(<A::Error as de::Error>::duplicate_field(
5892										"maintainer",
5893									));
5894								}
5895								r#maintainer_property = Some({
5896									struct DeserializeWith(Vec<MaintainerProperty>);
5897									impl<'de> Deserialize<'de> for DeserializeWith {
5898										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5899										where
5900											D: Deserializer<'de>,
5901										{
5902											Ok(DeserializeWith(serde_with::As::<
5903												serde_with::OneOrMany<serde_with::Same>,
5904											>::deserialize(deserializer)?))
5905										}
5906									}
5907									match map.next_value::<DeserializeWith>() {
5908										Ok(deserialize_with) => deserialize_with.0,
5909										Err(err) => {
5910											return Err(err);
5911										}
5912									}
5913								});
5914							}
5915							Field::Material => {
5916								if r#material_property.is_some() {
5917									return Err(<A::Error as de::Error>::duplicate_field(
5918										"material",
5919									));
5920								}
5921								r#material_property = Some({
5922									struct DeserializeWith(Vec<MaterialProperty>);
5923									impl<'de> Deserialize<'de> for DeserializeWith {
5924										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5925										where
5926											D: Deserializer<'de>,
5927										{
5928											Ok(DeserializeWith(serde_with::As::<
5929												serde_with::OneOrMany<serde_with::Same>,
5930											>::deserialize(deserializer)?))
5931										}
5932									}
5933									match map.next_value::<DeserializeWith>() {
5934										Ok(deserialize_with) => deserialize_with.0,
5935										Err(err) => {
5936											return Err(err);
5937										}
5938									}
5939								});
5940							}
5941							Field::MaterialExtent => {
5942								if r#material_extent_property.is_some() {
5943									return Err(<A::Error as de::Error>::duplicate_field(
5944										"materialExtent",
5945									));
5946								}
5947								r#material_extent_property = Some({
5948									struct DeserializeWith(Vec<MaterialExtentProperty>);
5949									impl<'de> Deserialize<'de> for DeserializeWith {
5950										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5951										where
5952											D: Deserializer<'de>,
5953										{
5954											Ok(DeserializeWith(serde_with::As::<
5955												serde_with::OneOrMany<serde_with::Same>,
5956											>::deserialize(deserializer)?))
5957										}
5958									}
5959									match map.next_value::<DeserializeWith>() {
5960										Ok(deserialize_with) => deserialize_with.0,
5961										Err(err) => {
5962											return Err(err);
5963										}
5964									}
5965								});
5966							}
5967							Field::Mentions => {
5968								if r#mentions_property.is_some() {
5969									return Err(<A::Error as de::Error>::duplicate_field(
5970										"mentions",
5971									));
5972								}
5973								r#mentions_property = Some({
5974									struct DeserializeWith(Vec<MentionsProperty>);
5975									impl<'de> Deserialize<'de> for DeserializeWith {
5976										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5977										where
5978											D: Deserializer<'de>,
5979										{
5980											Ok(DeserializeWith(serde_with::As::<
5981												serde_with::OneOrMany<serde_with::Same>,
5982											>::deserialize(deserializer)?))
5983										}
5984									}
5985									match map.next_value::<DeserializeWith>() {
5986										Ok(deserialize_with) => deserialize_with.0,
5987										Err(err) => {
5988											return Err(err);
5989										}
5990									}
5991								});
5992							}
5993							Field::Offers => {
5994								if r#offers_property.is_some() {
5995									return Err(<A::Error as de::Error>::duplicate_field("offers"));
5996								}
5997								r#offers_property = Some({
5998									struct DeserializeWith(Vec<OffersProperty>);
5999									impl<'de> Deserialize<'de> for DeserializeWith {
6000										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6001										where
6002											D: Deserializer<'de>,
6003										{
6004											Ok(DeserializeWith(serde_with::As::<
6005												serde_with::OneOrMany<serde_with::Same>,
6006											>::deserialize(deserializer)?))
6007										}
6008									}
6009									match map.next_value::<DeserializeWith>() {
6010										Ok(deserialize_with) => deserialize_with.0,
6011										Err(err) => {
6012											return Err(err);
6013										}
6014									}
6015								});
6016							}
6017							Field::Pattern => {
6018								if r#pattern_property.is_some() {
6019									return Err(<A::Error as de::Error>::duplicate_field(
6020										"pattern",
6021									));
6022								}
6023								r#pattern_property = Some({
6024									struct DeserializeWith(Vec<PatternProperty>);
6025									impl<'de> Deserialize<'de> for DeserializeWith {
6026										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6027										where
6028											D: Deserializer<'de>,
6029										{
6030											Ok(DeserializeWith(serde_with::As::<
6031												serde_with::OneOrMany<serde_with::Same>,
6032											>::deserialize(deserializer)?))
6033										}
6034									}
6035									match map.next_value::<DeserializeWith>() {
6036										Ok(deserialize_with) => deserialize_with.0,
6037										Err(err) => {
6038											return Err(err);
6039										}
6040									}
6041								});
6042							}
6043							Field::Position => {
6044								if r#position_property.is_some() {
6045									return Err(<A::Error as de::Error>::duplicate_field(
6046										"position",
6047									));
6048								}
6049								r#position_property = Some({
6050									struct DeserializeWith(Vec<PositionProperty>);
6051									impl<'de> Deserialize<'de> for DeserializeWith {
6052										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6053										where
6054											D: Deserializer<'de>,
6055										{
6056											Ok(DeserializeWith(serde_with::As::<
6057												serde_with::OneOrMany<serde_with::Same>,
6058											>::deserialize(deserializer)?))
6059										}
6060									}
6061									match map.next_value::<DeserializeWith>() {
6062										Ok(deserialize_with) => deserialize_with.0,
6063										Err(err) => {
6064											return Err(err);
6065										}
6066									}
6067								});
6068							}
6069							Field::Producer => {
6070								if r#producer_property.is_some() {
6071									return Err(<A::Error as de::Error>::duplicate_field(
6072										"producer",
6073									));
6074								}
6075								r#producer_property = Some({
6076									struct DeserializeWith(Vec<ProducerProperty>);
6077									impl<'de> Deserialize<'de> for DeserializeWith {
6078										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6079										where
6080											D: Deserializer<'de>,
6081										{
6082											Ok(DeserializeWith(serde_with::As::<
6083												serde_with::OneOrMany<serde_with::Same>,
6084											>::deserialize(deserializer)?))
6085										}
6086									}
6087									match map.next_value::<DeserializeWith>() {
6088										Ok(deserialize_with) => deserialize_with.0,
6089										Err(err) => {
6090											return Err(err);
6091										}
6092									}
6093								});
6094							}
6095							Field::Provider => {
6096								if r#provider_property.is_some() {
6097									return Err(<A::Error as de::Error>::duplicate_field(
6098										"provider",
6099									));
6100								}
6101								r#provider_property = Some({
6102									struct DeserializeWith(Vec<ProviderProperty>);
6103									impl<'de> Deserialize<'de> for DeserializeWith {
6104										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6105										where
6106											D: Deserializer<'de>,
6107										{
6108											Ok(DeserializeWith(serde_with::As::<
6109												serde_with::OneOrMany<serde_with::Same>,
6110											>::deserialize(deserializer)?))
6111										}
6112									}
6113									match map.next_value::<DeserializeWith>() {
6114										Ok(deserialize_with) => deserialize_with.0,
6115										Err(err) => {
6116											return Err(err);
6117										}
6118									}
6119								});
6120							}
6121							Field::Publication => {
6122								if r#publication_property.is_some() {
6123									return Err(<A::Error as de::Error>::duplicate_field(
6124										"publication",
6125									));
6126								}
6127								r#publication_property = Some({
6128									struct DeserializeWith(Vec<PublicationProperty>);
6129									impl<'de> Deserialize<'de> for DeserializeWith {
6130										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6131										where
6132											D: Deserializer<'de>,
6133										{
6134											Ok(DeserializeWith(serde_with::As::<
6135												serde_with::OneOrMany<serde_with::Same>,
6136											>::deserialize(deserializer)?))
6137										}
6138									}
6139									match map.next_value::<DeserializeWith>() {
6140										Ok(deserialize_with) => deserialize_with.0,
6141										Err(err) => {
6142											return Err(err);
6143										}
6144									}
6145								});
6146							}
6147							Field::Publisher => {
6148								if r#publisher_property.is_some() {
6149									return Err(<A::Error as de::Error>::duplicate_field(
6150										"publisher",
6151									));
6152								}
6153								r#publisher_property = Some({
6154									struct DeserializeWith(Vec<PublisherProperty>);
6155									impl<'de> Deserialize<'de> for DeserializeWith {
6156										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6157										where
6158											D: Deserializer<'de>,
6159										{
6160											Ok(DeserializeWith(serde_with::As::<
6161												serde_with::OneOrMany<serde_with::Same>,
6162											>::deserialize(deserializer)?))
6163										}
6164									}
6165									match map.next_value::<DeserializeWith>() {
6166										Ok(deserialize_with) => deserialize_with.0,
6167										Err(err) => {
6168											return Err(err);
6169										}
6170									}
6171								});
6172							}
6173							Field::PublisherImprint => {
6174								if r#publisher_imprint_property.is_some() {
6175									return Err(<A::Error as de::Error>::duplicate_field(
6176										"publisherImprint",
6177									));
6178								}
6179								r#publisher_imprint_property = Some({
6180									struct DeserializeWith(Vec<PublisherImprintProperty>);
6181									impl<'de> Deserialize<'de> for DeserializeWith {
6182										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6183										where
6184											D: Deserializer<'de>,
6185										{
6186											Ok(DeserializeWith(serde_with::As::<
6187												serde_with::OneOrMany<serde_with::Same>,
6188											>::deserialize(deserializer)?))
6189										}
6190									}
6191									match map.next_value::<DeserializeWith>() {
6192										Ok(deserialize_with) => deserialize_with.0,
6193										Err(err) => {
6194											return Err(err);
6195										}
6196									}
6197								});
6198							}
6199							Field::PublishingPrinciples => {
6200								if r#publishing_principles_property.is_some() {
6201									return Err(<A::Error as de::Error>::duplicate_field(
6202										"publishingPrinciples",
6203									));
6204								}
6205								r#publishing_principles_property = Some({
6206									struct DeserializeWith(Vec<PublishingPrinciplesProperty>);
6207									impl<'de> Deserialize<'de> for DeserializeWith {
6208										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6209										where
6210											D: Deserializer<'de>,
6211										{
6212											Ok(DeserializeWith(serde_with::As::<
6213												serde_with::OneOrMany<serde_with::Same>,
6214											>::deserialize(deserializer)?))
6215										}
6216									}
6217									match map.next_value::<DeserializeWith>() {
6218										Ok(deserialize_with) => deserialize_with.0,
6219										Err(err) => {
6220											return Err(err);
6221										}
6222									}
6223								});
6224							}
6225							Field::RecordedAt => {
6226								if r#recorded_at_property.is_some() {
6227									return Err(<A::Error as de::Error>::duplicate_field(
6228										"recordedAt",
6229									));
6230								}
6231								r#recorded_at_property = Some({
6232									struct DeserializeWith(Vec<RecordedAtProperty>);
6233									impl<'de> Deserialize<'de> for DeserializeWith {
6234										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6235										where
6236											D: Deserializer<'de>,
6237										{
6238											Ok(DeserializeWith(serde_with::As::<
6239												serde_with::OneOrMany<serde_with::Same>,
6240											>::deserialize(deserializer)?))
6241										}
6242									}
6243									match map.next_value::<DeserializeWith>() {
6244										Ok(deserialize_with) => deserialize_with.0,
6245										Err(err) => {
6246											return Err(err);
6247										}
6248									}
6249								});
6250							}
6251							Field::ReleasedEvent => {
6252								if r#released_event_property.is_some() {
6253									return Err(<A::Error as de::Error>::duplicate_field(
6254										"releasedEvent",
6255									));
6256								}
6257								r#released_event_property = Some({
6258									struct DeserializeWith(Vec<ReleasedEventProperty>);
6259									impl<'de> Deserialize<'de> for DeserializeWith {
6260										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6261										where
6262											D: Deserializer<'de>,
6263										{
6264											Ok(DeserializeWith(serde_with::As::<
6265												serde_with::OneOrMany<serde_with::Same>,
6266											>::deserialize(deserializer)?))
6267										}
6268									}
6269									match map.next_value::<DeserializeWith>() {
6270										Ok(deserialize_with) => deserialize_with.0,
6271										Err(err) => {
6272											return Err(err);
6273										}
6274									}
6275								});
6276							}
6277							Field::Review => {
6278								if r#review_property.is_some() {
6279									return Err(<A::Error as de::Error>::duplicate_field("review"));
6280								}
6281								r#review_property = Some({
6282									struct DeserializeWith(Vec<ReviewProperty>);
6283									impl<'de> Deserialize<'de> for DeserializeWith {
6284										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6285										where
6286											D: Deserializer<'de>,
6287										{
6288											Ok(DeserializeWith(serde_with::As::<
6289												serde_with::OneOrMany<serde_with::Same>,
6290											>::deserialize(deserializer)?))
6291										}
6292									}
6293									match map.next_value::<DeserializeWith>() {
6294										Ok(deserialize_with) => deserialize_with.0,
6295										Err(err) => {
6296											return Err(err);
6297										}
6298									}
6299								});
6300							}
6301							Field::Reviews => {
6302								if r#reviews_property.is_some() {
6303									return Err(<A::Error as de::Error>::duplicate_field(
6304										"reviews",
6305									));
6306								}
6307								r#reviews_property = Some({
6308									struct DeserializeWith(Vec<ReviewsProperty>);
6309									impl<'de> Deserialize<'de> for DeserializeWith {
6310										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6311										where
6312											D: Deserializer<'de>,
6313										{
6314											Ok(DeserializeWith(serde_with::As::<
6315												serde_with::OneOrMany<serde_with::Same>,
6316											>::deserialize(deserializer)?))
6317										}
6318									}
6319									match map.next_value::<DeserializeWith>() {
6320										Ok(deserialize_with) => deserialize_with.0,
6321										Err(err) => {
6322											return Err(err);
6323										}
6324									}
6325								});
6326							}
6327							Field::SchemaVersion => {
6328								if r#schema_version_property.is_some() {
6329									return Err(<A::Error as de::Error>::duplicate_field(
6330										"schemaVersion",
6331									));
6332								}
6333								r#schema_version_property = Some({
6334									struct DeserializeWith(Vec<SchemaVersionProperty>);
6335									impl<'de> Deserialize<'de> for DeserializeWith {
6336										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6337										where
6338											D: Deserializer<'de>,
6339										{
6340											Ok(DeserializeWith(serde_with::As::<
6341												serde_with::OneOrMany<serde_with::Same>,
6342											>::deserialize(deserializer)?))
6343										}
6344									}
6345									match map.next_value::<DeserializeWith>() {
6346										Ok(deserialize_with) => deserialize_with.0,
6347										Err(err) => {
6348											return Err(err);
6349										}
6350									}
6351								});
6352							}
6353							Field::SdDatePublished => {
6354								if r#sd_date_published_property.is_some() {
6355									return Err(<A::Error as de::Error>::duplicate_field(
6356										"sdDatePublished",
6357									));
6358								}
6359								r#sd_date_published_property = Some({
6360									struct DeserializeWith(Vec<SdDatePublishedProperty>);
6361									impl<'de> Deserialize<'de> for DeserializeWith {
6362										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6363										where
6364											D: Deserializer<'de>,
6365										{
6366											Ok(DeserializeWith(serde_with::As::<
6367												serde_with::OneOrMany<serde_with::Same>,
6368											>::deserialize(deserializer)?))
6369										}
6370									}
6371									match map.next_value::<DeserializeWith>() {
6372										Ok(deserialize_with) => deserialize_with.0,
6373										Err(err) => {
6374											return Err(err);
6375										}
6376									}
6377								});
6378							}
6379							Field::SdLicense => {
6380								if r#sd_license_property.is_some() {
6381									return Err(<A::Error as de::Error>::duplicate_field(
6382										"sdLicense",
6383									));
6384								}
6385								r#sd_license_property = Some({
6386									struct DeserializeWith(Vec<SdLicenseProperty>);
6387									impl<'de> Deserialize<'de> for DeserializeWith {
6388										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6389										where
6390											D: Deserializer<'de>,
6391										{
6392											Ok(DeserializeWith(serde_with::As::<
6393												serde_with::OneOrMany<serde_with::Same>,
6394											>::deserialize(deserializer)?))
6395										}
6396									}
6397									match map.next_value::<DeserializeWith>() {
6398										Ok(deserialize_with) => deserialize_with.0,
6399										Err(err) => {
6400											return Err(err);
6401										}
6402									}
6403								});
6404							}
6405							Field::SdPublisher => {
6406								if r#sd_publisher_property.is_some() {
6407									return Err(<A::Error as de::Error>::duplicate_field(
6408										"sdPublisher",
6409									));
6410								}
6411								r#sd_publisher_property = Some({
6412									struct DeserializeWith(Vec<SdPublisherProperty>);
6413									impl<'de> Deserialize<'de> for DeserializeWith {
6414										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6415										where
6416											D: Deserializer<'de>,
6417										{
6418											Ok(DeserializeWith(serde_with::As::<
6419												serde_with::OneOrMany<serde_with::Same>,
6420											>::deserialize(deserializer)?))
6421										}
6422									}
6423									match map.next_value::<DeserializeWith>() {
6424										Ok(deserialize_with) => deserialize_with.0,
6425										Err(err) => {
6426											return Err(err);
6427										}
6428									}
6429								});
6430							}
6431							Field::Size => {
6432								if r#size_property.is_some() {
6433									return Err(<A::Error as de::Error>::duplicate_field("size"));
6434								}
6435								r#size_property = Some({
6436									struct DeserializeWith(Vec<SizeProperty>);
6437									impl<'de> Deserialize<'de> for DeserializeWith {
6438										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6439										where
6440											D: Deserializer<'de>,
6441										{
6442											Ok(DeserializeWith(serde_with::As::<
6443												serde_with::OneOrMany<serde_with::Same>,
6444											>::deserialize(deserializer)?))
6445										}
6446									}
6447									match map.next_value::<DeserializeWith>() {
6448										Ok(deserialize_with) => deserialize_with.0,
6449										Err(err) => {
6450											return Err(err);
6451										}
6452									}
6453								});
6454							}
6455							Field::SourceOrganization => {
6456								if r#source_organization_property.is_some() {
6457									return Err(<A::Error as de::Error>::duplicate_field(
6458										"sourceOrganization",
6459									));
6460								}
6461								r#source_organization_property = Some({
6462									struct DeserializeWith(Vec<SourceOrganizationProperty>);
6463									impl<'de> Deserialize<'de> for DeserializeWith {
6464										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6465										where
6466											D: Deserializer<'de>,
6467										{
6468											Ok(DeserializeWith(serde_with::As::<
6469												serde_with::OneOrMany<serde_with::Same>,
6470											>::deserialize(deserializer)?))
6471										}
6472									}
6473									match map.next_value::<DeserializeWith>() {
6474										Ok(deserialize_with) => deserialize_with.0,
6475										Err(err) => {
6476											return Err(err);
6477										}
6478									}
6479								});
6480							}
6481							Field::Spatial => {
6482								if r#spatial_property.is_some() {
6483									return Err(<A::Error as de::Error>::duplicate_field(
6484										"spatial",
6485									));
6486								}
6487								r#spatial_property = Some({
6488									struct DeserializeWith(Vec<SpatialProperty>);
6489									impl<'de> Deserialize<'de> for DeserializeWith {
6490										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6491										where
6492											D: Deserializer<'de>,
6493										{
6494											Ok(DeserializeWith(serde_with::As::<
6495												serde_with::OneOrMany<serde_with::Same>,
6496											>::deserialize(deserializer)?))
6497										}
6498									}
6499									match map.next_value::<DeserializeWith>() {
6500										Ok(deserialize_with) => deserialize_with.0,
6501										Err(err) => {
6502											return Err(err);
6503										}
6504									}
6505								});
6506							}
6507							Field::SpatialCoverage => {
6508								if r#spatial_coverage_property.is_some() {
6509									return Err(<A::Error as de::Error>::duplicate_field(
6510										"spatialCoverage",
6511									));
6512								}
6513								r#spatial_coverage_property = Some({
6514									struct DeserializeWith(Vec<SpatialCoverageProperty>);
6515									impl<'de> Deserialize<'de> for DeserializeWith {
6516										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6517										where
6518											D: Deserializer<'de>,
6519										{
6520											Ok(DeserializeWith(serde_with::As::<
6521												serde_with::OneOrMany<serde_with::Same>,
6522											>::deserialize(deserializer)?))
6523										}
6524									}
6525									match map.next_value::<DeserializeWith>() {
6526										Ok(deserialize_with) => deserialize_with.0,
6527										Err(err) => {
6528											return Err(err);
6529										}
6530									}
6531								});
6532							}
6533							Field::Sponsor => {
6534								if r#sponsor_property.is_some() {
6535									return Err(<A::Error as de::Error>::duplicate_field(
6536										"sponsor",
6537									));
6538								}
6539								r#sponsor_property = Some({
6540									struct DeserializeWith(Vec<SponsorProperty>);
6541									impl<'de> Deserialize<'de> for DeserializeWith {
6542										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6543										where
6544											D: Deserializer<'de>,
6545										{
6546											Ok(DeserializeWith(serde_with::As::<
6547												serde_with::OneOrMany<serde_with::Same>,
6548											>::deserialize(deserializer)?))
6549										}
6550									}
6551									match map.next_value::<DeserializeWith>() {
6552										Ok(deserialize_with) => deserialize_with.0,
6553										Err(err) => {
6554											return Err(err);
6555										}
6556									}
6557								});
6558							}
6559							Field::Teaches => {
6560								if r#teaches_property.is_some() {
6561									return Err(<A::Error as de::Error>::duplicate_field(
6562										"teaches",
6563									));
6564								}
6565								r#teaches_property = Some({
6566									struct DeserializeWith(Vec<TeachesProperty>);
6567									impl<'de> Deserialize<'de> for DeserializeWith {
6568										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6569										where
6570											D: Deserializer<'de>,
6571										{
6572											Ok(DeserializeWith(serde_with::As::<
6573												serde_with::OneOrMany<serde_with::Same>,
6574											>::deserialize(deserializer)?))
6575										}
6576									}
6577									match map.next_value::<DeserializeWith>() {
6578										Ok(deserialize_with) => deserialize_with.0,
6579										Err(err) => {
6580											return Err(err);
6581										}
6582									}
6583								});
6584							}
6585							Field::Temporal => {
6586								if r#temporal_property.is_some() {
6587									return Err(<A::Error as de::Error>::duplicate_field(
6588										"temporal",
6589									));
6590								}
6591								r#temporal_property = Some({
6592									struct DeserializeWith(Vec<TemporalProperty>);
6593									impl<'de> Deserialize<'de> for DeserializeWith {
6594										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6595										where
6596											D: Deserializer<'de>,
6597										{
6598											Ok(DeserializeWith(serde_with::As::<
6599												serde_with::OneOrMany<serde_with::Same>,
6600											>::deserialize(deserializer)?))
6601										}
6602									}
6603									match map.next_value::<DeserializeWith>() {
6604										Ok(deserialize_with) => deserialize_with.0,
6605										Err(err) => {
6606											return Err(err);
6607										}
6608									}
6609								});
6610							}
6611							Field::TemporalCoverage => {
6612								if r#temporal_coverage_property.is_some() {
6613									return Err(<A::Error as de::Error>::duplicate_field(
6614										"temporalCoverage",
6615									));
6616								}
6617								r#temporal_coverage_property = Some({
6618									struct DeserializeWith(Vec<TemporalCoverageProperty>);
6619									impl<'de> Deserialize<'de> for DeserializeWith {
6620										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6621										where
6622											D: Deserializer<'de>,
6623										{
6624											Ok(DeserializeWith(serde_with::As::<
6625												serde_with::OneOrMany<serde_with::Same>,
6626											>::deserialize(deserializer)?))
6627										}
6628									}
6629									match map.next_value::<DeserializeWith>() {
6630										Ok(deserialize_with) => deserialize_with.0,
6631										Err(err) => {
6632											return Err(err);
6633										}
6634									}
6635								});
6636							}
6637							Field::Text => {
6638								if r#text_property.is_some() {
6639									return Err(<A::Error as de::Error>::duplicate_field("text"));
6640								}
6641								r#text_property = Some({
6642									struct DeserializeWith(Vec<TextProperty>);
6643									impl<'de> Deserialize<'de> for DeserializeWith {
6644										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6645										where
6646											D: Deserializer<'de>,
6647										{
6648											Ok(DeserializeWith(serde_with::As::<
6649												serde_with::OneOrMany<serde_with::Same>,
6650											>::deserialize(deserializer)?))
6651										}
6652									}
6653									match map.next_value::<DeserializeWith>() {
6654										Ok(deserialize_with) => deserialize_with.0,
6655										Err(err) => {
6656											return Err(err);
6657										}
6658									}
6659								});
6660							}
6661							Field::Thumbnail => {
6662								if r#thumbnail_property.is_some() {
6663									return Err(<A::Error as de::Error>::duplicate_field(
6664										"thumbnail",
6665									));
6666								}
6667								r#thumbnail_property = Some({
6668									struct DeserializeWith(Vec<ThumbnailProperty>);
6669									impl<'de> Deserialize<'de> for DeserializeWith {
6670										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6671										where
6672											D: Deserializer<'de>,
6673										{
6674											Ok(DeserializeWith(serde_with::As::<
6675												serde_with::OneOrMany<serde_with::Same>,
6676											>::deserialize(deserializer)?))
6677										}
6678									}
6679									match map.next_value::<DeserializeWith>() {
6680										Ok(deserialize_with) => deserialize_with.0,
6681										Err(err) => {
6682											return Err(err);
6683										}
6684									}
6685								});
6686							}
6687							Field::ThumbnailUrl => {
6688								if r#thumbnail_url_property.is_some() {
6689									return Err(<A::Error as de::Error>::duplicate_field(
6690										"thumbnailUrl",
6691									));
6692								}
6693								r#thumbnail_url_property = Some({
6694									struct DeserializeWith(Vec<ThumbnailUrlProperty>);
6695									impl<'de> Deserialize<'de> for DeserializeWith {
6696										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6697										where
6698											D: Deserializer<'de>,
6699										{
6700											Ok(DeserializeWith(serde_with::As::<
6701												serde_with::OneOrMany<serde_with::Same>,
6702											>::deserialize(deserializer)?))
6703										}
6704									}
6705									match map.next_value::<DeserializeWith>() {
6706										Ok(deserialize_with) => deserialize_with.0,
6707										Err(err) => {
6708											return Err(err);
6709										}
6710									}
6711								});
6712							}
6713							Field::TimeRequired => {
6714								if r#time_required_property.is_some() {
6715									return Err(<A::Error as de::Error>::duplicate_field(
6716										"timeRequired",
6717									));
6718								}
6719								r#time_required_property = Some({
6720									struct DeserializeWith(Vec<TimeRequiredProperty>);
6721									impl<'de> Deserialize<'de> for DeserializeWith {
6722										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6723										where
6724											D: Deserializer<'de>,
6725										{
6726											Ok(DeserializeWith(serde_with::As::<
6727												serde_with::OneOrMany<serde_with::Same>,
6728											>::deserialize(deserializer)?))
6729										}
6730									}
6731									match map.next_value::<DeserializeWith>() {
6732										Ok(deserialize_with) => deserialize_with.0,
6733										Err(err) => {
6734											return Err(err);
6735										}
6736									}
6737								});
6738							}
6739							Field::TranslationOfWork => {
6740								if r#translation_of_work_property.is_some() {
6741									return Err(<A::Error as de::Error>::duplicate_field(
6742										"translationOfWork",
6743									));
6744								}
6745								r#translation_of_work_property = Some({
6746									struct DeserializeWith(Vec<TranslationOfWorkProperty>);
6747									impl<'de> Deserialize<'de> for DeserializeWith {
6748										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6749										where
6750											D: Deserializer<'de>,
6751										{
6752											Ok(DeserializeWith(serde_with::As::<
6753												serde_with::OneOrMany<serde_with::Same>,
6754											>::deserialize(deserializer)?))
6755										}
6756									}
6757									match map.next_value::<DeserializeWith>() {
6758										Ok(deserialize_with) => deserialize_with.0,
6759										Err(err) => {
6760											return Err(err);
6761										}
6762									}
6763								});
6764							}
6765							Field::Translator => {
6766								if r#translator_property.is_some() {
6767									return Err(<A::Error as de::Error>::duplicate_field(
6768										"translator",
6769									));
6770								}
6771								r#translator_property = Some({
6772									struct DeserializeWith(Vec<TranslatorProperty>);
6773									impl<'de> Deserialize<'de> for DeserializeWith {
6774										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6775										where
6776											D: Deserializer<'de>,
6777										{
6778											Ok(DeserializeWith(serde_with::As::<
6779												serde_with::OneOrMany<serde_with::Same>,
6780											>::deserialize(deserializer)?))
6781										}
6782									}
6783									match map.next_value::<DeserializeWith>() {
6784										Ok(deserialize_with) => deserialize_with.0,
6785										Err(err) => {
6786											return Err(err);
6787										}
6788									}
6789								});
6790							}
6791							Field::TypicalAgeRange => {
6792								if r#typical_age_range_property.is_some() {
6793									return Err(<A::Error as de::Error>::duplicate_field(
6794										"typicalAgeRange",
6795									));
6796								}
6797								r#typical_age_range_property = Some({
6798									struct DeserializeWith(Vec<TypicalAgeRangeProperty>);
6799									impl<'de> Deserialize<'de> for DeserializeWith {
6800										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6801										where
6802											D: Deserializer<'de>,
6803										{
6804											Ok(DeserializeWith(serde_with::As::<
6805												serde_with::OneOrMany<serde_with::Same>,
6806											>::deserialize(deserializer)?))
6807										}
6808									}
6809									match map.next_value::<DeserializeWith>() {
6810										Ok(deserialize_with) => deserialize_with.0,
6811										Err(err) => {
6812											return Err(err);
6813										}
6814									}
6815								});
6816							}
6817							Field::UsageInfo => {
6818								if r#usage_info_property.is_some() {
6819									return Err(<A::Error as de::Error>::duplicate_field(
6820										"usageInfo",
6821									));
6822								}
6823								r#usage_info_property = Some({
6824									struct DeserializeWith(Vec<UsageInfoProperty>);
6825									impl<'de> Deserialize<'de> for DeserializeWith {
6826										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6827										where
6828											D: Deserializer<'de>,
6829										{
6830											Ok(DeserializeWith(serde_with::As::<
6831												serde_with::OneOrMany<serde_with::Same>,
6832											>::deserialize(deserializer)?))
6833										}
6834									}
6835									match map.next_value::<DeserializeWith>() {
6836										Ok(deserialize_with) => deserialize_with.0,
6837										Err(err) => {
6838											return Err(err);
6839										}
6840									}
6841								});
6842							}
6843							Field::Version => {
6844								if r#version_property.is_some() {
6845									return Err(<A::Error as de::Error>::duplicate_field(
6846										"version",
6847									));
6848								}
6849								r#version_property = Some({
6850									struct DeserializeWith(Vec<VersionProperty>);
6851									impl<'de> Deserialize<'de> for DeserializeWith {
6852										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6853										where
6854											D: Deserializer<'de>,
6855										{
6856											Ok(DeserializeWith(serde_with::As::<
6857												serde_with::OneOrMany<serde_with::Same>,
6858											>::deserialize(deserializer)?))
6859										}
6860									}
6861									match map.next_value::<DeserializeWith>() {
6862										Ok(deserialize_with) => deserialize_with.0,
6863										Err(err) => {
6864											return Err(err);
6865										}
6866									}
6867								});
6868							}
6869							Field::Video => {
6870								if r#video_property.is_some() {
6871									return Err(<A::Error as de::Error>::duplicate_field("video"));
6872								}
6873								r#video_property = Some({
6874									struct DeserializeWith(Vec<VideoProperty>);
6875									impl<'de> Deserialize<'de> for DeserializeWith {
6876										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6877										where
6878											D: Deserializer<'de>,
6879										{
6880											Ok(DeserializeWith(serde_with::As::<
6881												serde_with::OneOrMany<serde_with::Same>,
6882											>::deserialize(deserializer)?))
6883										}
6884									}
6885									match map.next_value::<DeserializeWith>() {
6886										Ok(deserialize_with) => deserialize_with.0,
6887										Err(err) => {
6888											return Err(err);
6889										}
6890									}
6891								});
6892							}
6893							Field::WorkExample => {
6894								if r#work_example_property.is_some() {
6895									return Err(<A::Error as de::Error>::duplicate_field(
6896										"workExample",
6897									));
6898								}
6899								r#work_example_property = Some({
6900									struct DeserializeWith(Vec<WorkExampleProperty>);
6901									impl<'de> Deserialize<'de> for DeserializeWith {
6902										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6903										where
6904											D: Deserializer<'de>,
6905										{
6906											Ok(DeserializeWith(serde_with::As::<
6907												serde_with::OneOrMany<serde_with::Same>,
6908											>::deserialize(deserializer)?))
6909										}
6910									}
6911									match map.next_value::<DeserializeWith>() {
6912										Ok(deserialize_with) => deserialize_with.0,
6913										Err(err) => {
6914											return Err(err);
6915										}
6916									}
6917								});
6918							}
6919							Field::WorkTranslation => {
6920								if r#work_translation_property.is_some() {
6921									return Err(<A::Error as de::Error>::duplicate_field(
6922										"workTranslation",
6923									));
6924								}
6925								r#work_translation_property = Some({
6926									struct DeserializeWith(Vec<WorkTranslationProperty>);
6927									impl<'de> Deserialize<'de> for DeserializeWith {
6928										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6929										where
6930											D: Deserializer<'de>,
6931										{
6932											Ok(DeserializeWith(serde_with::As::<
6933												serde_with::OneOrMany<serde_with::Same>,
6934											>::deserialize(deserializer)?))
6935										}
6936									}
6937									match map.next_value::<DeserializeWith>() {
6938										Ok(deserialize_with) => deserialize_with.0,
6939										Err(err) => {
6940											return Err(err);
6941										}
6942									}
6943								});
6944							}
6945							Field::AdditionalType => {
6946								if r#additional_type_property.is_some() {
6947									return Err(<A::Error as de::Error>::duplicate_field(
6948										"additionalType",
6949									));
6950								}
6951								r#additional_type_property = Some({
6952									struct DeserializeWith(Vec<AdditionalTypeProperty>);
6953									impl<'de> Deserialize<'de> for DeserializeWith {
6954										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6955										where
6956											D: Deserializer<'de>,
6957										{
6958											Ok(DeserializeWith(serde_with::As::<
6959												serde_with::OneOrMany<serde_with::Same>,
6960											>::deserialize(deserializer)?))
6961										}
6962									}
6963									match map.next_value::<DeserializeWith>() {
6964										Ok(deserialize_with) => deserialize_with.0,
6965										Err(err) => {
6966											return Err(err);
6967										}
6968									}
6969								});
6970							}
6971							Field::AlternateName => {
6972								if r#alternate_name_property.is_some() {
6973									return Err(<A::Error as de::Error>::duplicate_field(
6974										"alternateName",
6975									));
6976								}
6977								r#alternate_name_property = Some({
6978									struct DeserializeWith(Vec<AlternateNameProperty>);
6979									impl<'de> Deserialize<'de> for DeserializeWith {
6980										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6981										where
6982											D: Deserializer<'de>,
6983										{
6984											Ok(DeserializeWith(serde_with::As::<
6985												serde_with::OneOrMany<serde_with::Same>,
6986											>::deserialize(deserializer)?))
6987										}
6988									}
6989									match map.next_value::<DeserializeWith>() {
6990										Ok(deserialize_with) => deserialize_with.0,
6991										Err(err) => {
6992											return Err(err);
6993										}
6994									}
6995								});
6996							}
6997							Field::Description => {
6998								if r#description_property.is_some() {
6999									return Err(<A::Error as de::Error>::duplicate_field(
7000										"description",
7001									));
7002								}
7003								r#description_property = Some({
7004									struct DeserializeWith(Vec<DescriptionProperty>);
7005									impl<'de> Deserialize<'de> for DeserializeWith {
7006										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7007										where
7008											D: Deserializer<'de>,
7009										{
7010											Ok(DeserializeWith(serde_with::As::<
7011												serde_with::OneOrMany<serde_with::Same>,
7012											>::deserialize(deserializer)?))
7013										}
7014									}
7015									match map.next_value::<DeserializeWith>() {
7016										Ok(deserialize_with) => deserialize_with.0,
7017										Err(err) => {
7018											return Err(err);
7019										}
7020									}
7021								});
7022							}
7023							Field::DisambiguatingDescription => {
7024								if r#disambiguating_description_property.is_some() {
7025									return Err(<A::Error as de::Error>::duplicate_field(
7026										"disambiguatingDescription",
7027									));
7028								}
7029								r#disambiguating_description_property = Some({
7030									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
7031									impl<'de> Deserialize<'de> for DeserializeWith {
7032										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7033										where
7034											D: Deserializer<'de>,
7035										{
7036											Ok(DeserializeWith(serde_with::As::<
7037												serde_with::OneOrMany<serde_with::Same>,
7038											>::deserialize(deserializer)?))
7039										}
7040									}
7041									match map.next_value::<DeserializeWith>() {
7042										Ok(deserialize_with) => deserialize_with.0,
7043										Err(err) => {
7044											return Err(err);
7045										}
7046									}
7047								});
7048							}
7049							Field::Identifier => {
7050								if r#identifier_property.is_some() {
7051									return Err(<A::Error as de::Error>::duplicate_field(
7052										"identifier",
7053									));
7054								}
7055								r#identifier_property = Some({
7056									struct DeserializeWith(Vec<IdentifierProperty>);
7057									impl<'de> Deserialize<'de> for DeserializeWith {
7058										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7059										where
7060											D: Deserializer<'de>,
7061										{
7062											Ok(DeserializeWith(serde_with::As::<
7063												serde_with::OneOrMany<serde_with::Same>,
7064											>::deserialize(deserializer)?))
7065										}
7066									}
7067									match map.next_value::<DeserializeWith>() {
7068										Ok(deserialize_with) => deserialize_with.0,
7069										Err(err) => {
7070											return Err(err);
7071										}
7072									}
7073								});
7074							}
7075							Field::Image => {
7076								if r#image_property.is_some() {
7077									return Err(<A::Error as de::Error>::duplicate_field("image"));
7078								}
7079								r#image_property = Some({
7080									struct DeserializeWith(Vec<ImageProperty>);
7081									impl<'de> Deserialize<'de> for DeserializeWith {
7082										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7083										where
7084											D: Deserializer<'de>,
7085										{
7086											Ok(DeserializeWith(serde_with::As::<
7087												serde_with::OneOrMany<serde_with::Same>,
7088											>::deserialize(deserializer)?))
7089										}
7090									}
7091									match map.next_value::<DeserializeWith>() {
7092										Ok(deserialize_with) => deserialize_with.0,
7093										Err(err) => {
7094											return Err(err);
7095										}
7096									}
7097								});
7098							}
7099							Field::MainEntityOfPage => {
7100								if r#main_entity_of_page_property.is_some() {
7101									return Err(<A::Error as de::Error>::duplicate_field(
7102										"mainEntityOfPage",
7103									));
7104								}
7105								r#main_entity_of_page_property = Some({
7106									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
7107									impl<'de> Deserialize<'de> for DeserializeWith {
7108										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7109										where
7110											D: Deserializer<'de>,
7111										{
7112											Ok(DeserializeWith(serde_with::As::<
7113												serde_with::OneOrMany<serde_with::Same>,
7114											>::deserialize(deserializer)?))
7115										}
7116									}
7117									match map.next_value::<DeserializeWith>() {
7118										Ok(deserialize_with) => deserialize_with.0,
7119										Err(err) => {
7120											return Err(err);
7121										}
7122									}
7123								});
7124							}
7125							Field::Name => {
7126								if r#name_property.is_some() {
7127									return Err(<A::Error as de::Error>::duplicate_field("name"));
7128								}
7129								r#name_property = Some({
7130									struct DeserializeWith(Vec<NameProperty>);
7131									impl<'de> Deserialize<'de> for DeserializeWith {
7132										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7133										where
7134											D: Deserializer<'de>,
7135										{
7136											Ok(DeserializeWith(serde_with::As::<
7137												serde_with::OneOrMany<serde_with::Same>,
7138											>::deserialize(deserializer)?))
7139										}
7140									}
7141									match map.next_value::<DeserializeWith>() {
7142										Ok(deserialize_with) => deserialize_with.0,
7143										Err(err) => {
7144											return Err(err);
7145										}
7146									}
7147								});
7148							}
7149							Field::PotentialAction => {
7150								if r#potential_action_property.is_some() {
7151									return Err(<A::Error as de::Error>::duplicate_field(
7152										"potentialAction",
7153									));
7154								}
7155								r#potential_action_property = Some({
7156									struct DeserializeWith(Vec<PotentialActionProperty>);
7157									impl<'de> Deserialize<'de> for DeserializeWith {
7158										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7159										where
7160											D: Deserializer<'de>,
7161										{
7162											Ok(DeserializeWith(serde_with::As::<
7163												serde_with::OneOrMany<serde_with::Same>,
7164											>::deserialize(deserializer)?))
7165										}
7166									}
7167									match map.next_value::<DeserializeWith>() {
7168										Ok(deserialize_with) => deserialize_with.0,
7169										Err(err) => {
7170											return Err(err);
7171										}
7172									}
7173								});
7174							}
7175							Field::SameAs => {
7176								if r#same_as_property.is_some() {
7177									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
7178								}
7179								r#same_as_property = Some({
7180									struct DeserializeWith(Vec<SameAsProperty>);
7181									impl<'de> Deserialize<'de> for DeserializeWith {
7182										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7183										where
7184											D: Deserializer<'de>,
7185										{
7186											Ok(DeserializeWith(serde_with::As::<
7187												serde_with::OneOrMany<serde_with::Same>,
7188											>::deserialize(deserializer)?))
7189										}
7190									}
7191									match map.next_value::<DeserializeWith>() {
7192										Ok(deserialize_with) => deserialize_with.0,
7193										Err(err) => {
7194											return Err(err);
7195										}
7196									}
7197								});
7198							}
7199							Field::SubjectOf => {
7200								if r#subject_of_property.is_some() {
7201									return Err(<A::Error as de::Error>::duplicate_field(
7202										"subjectOf",
7203									));
7204								}
7205								r#subject_of_property = Some({
7206									struct DeserializeWith(Vec<SubjectOfProperty>);
7207									impl<'de> Deserialize<'de> for DeserializeWith {
7208										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7209										where
7210											D: Deserializer<'de>,
7211										{
7212											Ok(DeserializeWith(serde_with::As::<
7213												serde_with::OneOrMany<serde_with::Same>,
7214											>::deserialize(deserializer)?))
7215										}
7216									}
7217									match map.next_value::<DeserializeWith>() {
7218										Ok(deserialize_with) => deserialize_with.0,
7219										Err(err) => {
7220											return Err(err);
7221										}
7222									}
7223								});
7224							}
7225							Field::Url => {
7226								if r#url_property.is_some() {
7227									return Err(<A::Error as de::Error>::duplicate_field("url"));
7228								}
7229								r#url_property = Some({
7230									struct DeserializeWith(Vec<UrlProperty>);
7231									impl<'de> Deserialize<'de> for DeserializeWith {
7232										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7233										where
7234											D: Deserializer<'de>,
7235										{
7236											Ok(DeserializeWith(serde_with::As::<
7237												serde_with::OneOrMany<serde_with::Same>,
7238											>::deserialize(deserializer)?))
7239										}
7240									}
7241									match map.next_value::<DeserializeWith>() {
7242										Ok(deserialize_with) => deserialize_with.0,
7243										Err(err) => {
7244											return Err(err);
7245										}
7246									}
7247								});
7248							}
7249							Field::Ignore => {
7250								let _ = map.next_value::<de::IgnoredAny>()?;
7251							}
7252						}
7253					}
7254					Ok(WebSite {
7255						r#issn: r#issn_property.unwrap_or_default(),
7256						r#about: r#about_property.unwrap_or_default(),
7257						r#abstract: r#abstract_property.unwrap_or_default(),
7258						r#access_mode: r#access_mode_property.unwrap_or_default(),
7259						r#access_mode_sufficient: r#access_mode_sufficient_property
7260							.unwrap_or_default(),
7261						r#accessibility_api: r#accessibility_api_property.unwrap_or_default(),
7262						r#accessibility_control: r#accessibility_control_property
7263							.unwrap_or_default(),
7264						r#accessibility_feature: r#accessibility_feature_property
7265							.unwrap_or_default(),
7266						r#accessibility_hazard: r#accessibility_hazard_property.unwrap_or_default(),
7267						r#accessibility_summary: r#accessibility_summary_property
7268							.unwrap_or_default(),
7269						r#accountable_person: r#accountable_person_property.unwrap_or_default(),
7270						r#acquire_license_page: r#acquire_license_page_property.unwrap_or_default(),
7271						r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
7272						r#alternative_headline: r#alternative_headline_property.unwrap_or_default(),
7273						r#archived_at: r#archived_at_property.unwrap_or_default(),
7274						r#assesses: r#assesses_property.unwrap_or_default(),
7275						r#associated_media: r#associated_media_property.unwrap_or_default(),
7276						r#audience: r#audience_property.unwrap_or_default(),
7277						r#audio: r#audio_property.unwrap_or_default(),
7278						r#author: r#author_property.unwrap_or_default(),
7279						r#award: r#award_property.unwrap_or_default(),
7280						r#awards: r#awards_property.unwrap_or_default(),
7281						r#character: r#character_property.unwrap_or_default(),
7282						r#citation: r#citation_property.unwrap_or_default(),
7283						r#comment: r#comment_property.unwrap_or_default(),
7284						r#comment_count: r#comment_count_property.unwrap_or_default(),
7285						r#conditions_of_access: r#conditions_of_access_property.unwrap_or_default(),
7286						r#content_location: r#content_location_property.unwrap_or_default(),
7287						r#content_rating: r#content_rating_property.unwrap_or_default(),
7288						r#content_reference_time: r#content_reference_time_property
7289							.unwrap_or_default(),
7290						r#contributor: r#contributor_property.unwrap_or_default(),
7291						r#copyright_holder: r#copyright_holder_property.unwrap_or_default(),
7292						r#copyright_notice: r#copyright_notice_property.unwrap_or_default(),
7293						r#copyright_year: r#copyright_year_property.unwrap_or_default(),
7294						r#correction: r#correction_property.unwrap_or_default(),
7295						r#country_of_origin: r#country_of_origin_property.unwrap_or_default(),
7296						r#creative_work_status: r#creative_work_status_property.unwrap_or_default(),
7297						r#creator: r#creator_property.unwrap_or_default(),
7298						r#credit_text: r#credit_text_property.unwrap_or_default(),
7299						r#date_created: r#date_created_property.unwrap_or_default(),
7300						r#date_modified: r#date_modified_property.unwrap_or_default(),
7301						r#date_published: r#date_published_property.unwrap_or_default(),
7302						r#discussion_url: r#discussion_url_property.unwrap_or_default(),
7303						r#edit_eidr: r#edit_eidr_property.unwrap_or_default(),
7304						r#editor: r#editor_property.unwrap_or_default(),
7305						r#educational_alignment: r#educational_alignment_property
7306							.unwrap_or_default(),
7307						r#educational_level: r#educational_level_property.unwrap_or_default(),
7308						r#educational_use: r#educational_use_property.unwrap_or_default(),
7309						r#encoding: r#encoding_property.unwrap_or_default(),
7310						r#encoding_format: r#encoding_format_property.unwrap_or_default(),
7311						r#encodings: r#encodings_property.unwrap_or_default(),
7312						r#example_of_work: r#example_of_work_property.unwrap_or_default(),
7313						r#expires: r#expires_property.unwrap_or_default(),
7314						r#file_format: r#file_format_property.unwrap_or_default(),
7315						r#funder: r#funder_property.unwrap_or_default(),
7316						r#funding: r#funding_property.unwrap_or_default(),
7317						r#genre: r#genre_property.unwrap_or_default(),
7318						r#has_part: r#has_part_property.unwrap_or_default(),
7319						r#headline: r#headline_property.unwrap_or_default(),
7320						r#in_language: r#in_language_property.unwrap_or_default(),
7321						r#interaction_statistic: r#interaction_statistic_property
7322							.unwrap_or_default(),
7323						r#interactivity_type: r#interactivity_type_property.unwrap_or_default(),
7324						r#interpreted_as_claim: r#interpreted_as_claim_property.unwrap_or_default(),
7325						r#is_accessible_for_free: r#is_accessible_for_free_property
7326							.unwrap_or_default(),
7327						r#is_based_on: r#is_based_on_property.unwrap_or_default(),
7328						r#is_based_on_url: r#is_based_on_url_property.unwrap_or_default(),
7329						r#is_family_friendly: r#is_family_friendly_property.unwrap_or_default(),
7330						r#is_part_of: r#is_part_of_property.unwrap_or_default(),
7331						r#keywords: r#keywords_property.unwrap_or_default(),
7332						r#learning_resource_type: r#learning_resource_type_property
7333							.unwrap_or_default(),
7334						r#license: r#license_property.unwrap_or_default(),
7335						r#location_created: r#location_created_property.unwrap_or_default(),
7336						r#main_entity: r#main_entity_property.unwrap_or_default(),
7337						r#maintainer: r#maintainer_property.unwrap_or_default(),
7338						r#material: r#material_property.unwrap_or_default(),
7339						r#material_extent: r#material_extent_property.unwrap_or_default(),
7340						r#mentions: r#mentions_property.unwrap_or_default(),
7341						r#offers: r#offers_property.unwrap_or_default(),
7342						r#pattern: r#pattern_property.unwrap_or_default(),
7343						r#position: r#position_property.unwrap_or_default(),
7344						r#producer: r#producer_property.unwrap_or_default(),
7345						r#provider: r#provider_property.unwrap_or_default(),
7346						r#publication: r#publication_property.unwrap_or_default(),
7347						r#publisher: r#publisher_property.unwrap_or_default(),
7348						r#publisher_imprint: r#publisher_imprint_property.unwrap_or_default(),
7349						r#publishing_principles: r#publishing_principles_property
7350							.unwrap_or_default(),
7351						r#recorded_at: r#recorded_at_property.unwrap_or_default(),
7352						r#released_event: r#released_event_property.unwrap_or_default(),
7353						r#review: r#review_property.unwrap_or_default(),
7354						r#reviews: r#reviews_property.unwrap_or_default(),
7355						r#schema_version: r#schema_version_property.unwrap_or_default(),
7356						r#sd_date_published: r#sd_date_published_property.unwrap_or_default(),
7357						r#sd_license: r#sd_license_property.unwrap_or_default(),
7358						r#sd_publisher: r#sd_publisher_property.unwrap_or_default(),
7359						r#size: r#size_property.unwrap_or_default(),
7360						r#source_organization: r#source_organization_property.unwrap_or_default(),
7361						r#spatial: r#spatial_property.unwrap_or_default(),
7362						r#spatial_coverage: r#spatial_coverage_property.unwrap_or_default(),
7363						r#sponsor: r#sponsor_property.unwrap_or_default(),
7364						r#teaches: r#teaches_property.unwrap_or_default(),
7365						r#temporal: r#temporal_property.unwrap_or_default(),
7366						r#temporal_coverage: r#temporal_coverage_property.unwrap_or_default(),
7367						r#text: r#text_property.unwrap_or_default(),
7368						r#thumbnail: r#thumbnail_property.unwrap_or_default(),
7369						r#thumbnail_url: r#thumbnail_url_property.unwrap_or_default(),
7370						r#time_required: r#time_required_property.unwrap_or_default(),
7371						r#translation_of_work: r#translation_of_work_property.unwrap_or_default(),
7372						r#translator: r#translator_property.unwrap_or_default(),
7373						r#typical_age_range: r#typical_age_range_property.unwrap_or_default(),
7374						r#usage_info: r#usage_info_property.unwrap_or_default(),
7375						r#version: r#version_property.unwrap_or_default(),
7376						r#video: r#video_property.unwrap_or_default(),
7377						r#work_example: r#work_example_property.unwrap_or_default(),
7378						r#work_translation: r#work_translation_property.unwrap_or_default(),
7379						r#additional_type: r#additional_type_property.unwrap_or_default(),
7380						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
7381						r#description: r#description_property.unwrap_or_default(),
7382						r#disambiguating_description: r#disambiguating_description_property
7383							.unwrap_or_default(),
7384						r#identifier: r#identifier_property.unwrap_or_default(),
7385						r#image: r#image_property.unwrap_or_default(),
7386						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
7387						r#name: r#name_property.unwrap_or_default(),
7388						r#potential_action: r#potential_action_property.unwrap_or_default(),
7389						r#same_as: r#same_as_property.unwrap_or_default(),
7390						r#subject_of: r#subject_of_property.unwrap_or_default(),
7391						r#url: r#url_property.unwrap_or_default(),
7392					})
7393				}
7394			}
7395			const FIELDS: &[&str] = &[
7396				"issn",
7397				"about",
7398				"abstract",
7399				"accessMode",
7400				"accessModeSufficient",
7401				"accessibilityAPI",
7402				"accessibilityControl",
7403				"accessibilityFeature",
7404				"accessibilityHazard",
7405				"accessibilitySummary",
7406				"accountablePerson",
7407				"acquireLicensePage",
7408				"aggregateRating",
7409				"alternativeHeadline",
7410				"archivedAt",
7411				"assesses",
7412				"associatedMedia",
7413				"audience",
7414				"audio",
7415				"author",
7416				"award",
7417				"awards",
7418				"character",
7419				"citation",
7420				"comment",
7421				"commentCount",
7422				"conditionsOfAccess",
7423				"contentLocation",
7424				"contentRating",
7425				"contentReferenceTime",
7426				"contributor",
7427				"copyrightHolder",
7428				"copyrightNotice",
7429				"copyrightYear",
7430				"correction",
7431				"countryOfOrigin",
7432				"creativeWorkStatus",
7433				"creator",
7434				"creditText",
7435				"dateCreated",
7436				"dateModified",
7437				"datePublished",
7438				"discussionUrl",
7439				"editEIDR",
7440				"editor",
7441				"educationalAlignment",
7442				"educationalLevel",
7443				"educationalUse",
7444				"encoding",
7445				"encodingFormat",
7446				"encodings",
7447				"exampleOfWork",
7448				"expires",
7449				"fileFormat",
7450				"funder",
7451				"funding",
7452				"genre",
7453				"hasPart",
7454				"headline",
7455				"inLanguage",
7456				"interactionStatistic",
7457				"interactivityType",
7458				"interpretedAsClaim",
7459				"isAccessibleForFree",
7460				"isBasedOn",
7461				"isBasedOnUrl",
7462				"isFamilyFriendly",
7463				"isPartOf",
7464				"keywords",
7465				"learningResourceType",
7466				"license",
7467				"locationCreated",
7468				"mainEntity",
7469				"maintainer",
7470				"material",
7471				"materialExtent",
7472				"mentions",
7473				"offers",
7474				"pattern",
7475				"position",
7476				"producer",
7477				"provider",
7478				"publication",
7479				"publisher",
7480				"publisherImprint",
7481				"publishingPrinciples",
7482				"recordedAt",
7483				"releasedEvent",
7484				"review",
7485				"reviews",
7486				"schemaVersion",
7487				"sdDatePublished",
7488				"sdLicense",
7489				"sdPublisher",
7490				"size",
7491				"sourceOrganization",
7492				"spatial",
7493				"spatialCoverage",
7494				"sponsor",
7495				"teaches",
7496				"temporal",
7497				"temporalCoverage",
7498				"text",
7499				"thumbnail",
7500				"thumbnailUrl",
7501				"timeRequired",
7502				"translationOfWork",
7503				"translator",
7504				"typicalAgeRange",
7505				"usageInfo",
7506				"version",
7507				"video",
7508				"workExample",
7509				"workTranslation",
7510				"additionalType",
7511				"alternateName",
7512				"description",
7513				"disambiguatingDescription",
7514				"identifier",
7515				"image",
7516				"mainEntityOfPage",
7517				"name",
7518				"potentialAction",
7519				"sameAs",
7520				"subjectOf",
7521				"url",
7522			];
7523			deserializer.deserialize_struct("WebSite", FIELDS, ClassVisitor)
7524		}
7525	}
7526}
schema_org_types/schemas/classes/web_site.rs

schema_org_types/schemas/classes/
web_site.rs
