schema_org_types/schemas/classes/
message.rs

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

schema_org_types/schemas/classes/
message.rs
