schema_org_types/schemas/classes/
conversation.rs

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

schema_org_types/schemas/classes/
conversation.rs
