schema_org_types/schemas/classes/
drawing.rs

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

schema_org_types/schemas/classes/
drawing.rs
