schema_org_types/schemas/classes/
game.rs

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

schema_org_types/schemas/classes/
game.rs
