schema_org_types/schemas/classes/
video_game.rs

1use super::*;
2/// <https://schema.org/VideoGame>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct VideoGame {
6	/// <https://schema.org/actor>
7	pub r#actor: Vec<ActorProperty>,
8	/// <https://schema.org/actors>
9	#[deprecated = "This schema is superseded by <https://schema.org/actor>."]
10	pub r#actors: Vec<ActorsProperty>,
11	/// <https://schema.org/cheatCode>
12	pub r#cheat_code: Vec<CheatCodeProperty>,
13	/// <https://schema.org/director>
14	pub r#director: Vec<DirectorProperty>,
15	/// <https://schema.org/directors>
16	#[deprecated = "This schema is superseded by <https://schema.org/director>."]
17	pub r#directors: Vec<DirectorsProperty>,
18	/// <https://schema.org/gameEdition>
19	pub r#game_edition: Vec<GameEditionProperty>,
20	/// <https://schema.org/gamePlatform>
21	pub r#game_platform: Vec<GamePlatformProperty>,
22	/// <https://schema.org/gameServer>
23	pub r#game_server: Vec<GameServerProperty>,
24	/// <https://schema.org/gameTip>
25	pub r#game_tip: Vec<GameTipProperty>,
26	/// <https://schema.org/musicBy>
27	pub r#music_by: Vec<MusicByProperty>,
28	/// <https://schema.org/playMode>
29	pub r#play_mode: Vec<PlayModeProperty>,
30	/// <https://schema.org/trailer>
31	pub r#trailer: Vec<TrailerProperty>,
32	/// <https://schema.org/about>
33	pub r#about: Vec<AboutProperty>,
34	/// <https://schema.org/abstract>
35	pub r#abstract: Vec<AbstractProperty>,
36	/// <https://schema.org/accessMode>
37	pub r#access_mode: Vec<AccessModeProperty>,
38	/// <https://schema.org/accessModeSufficient>
39	pub r#access_mode_sufficient: Vec<AccessModeSufficientProperty>,
40	/// <https://schema.org/accessibilityAPI>
41	pub r#accessibility_api: Vec<AccessibilityApiProperty>,
42	/// <https://schema.org/accessibilityControl>
43	pub r#accessibility_control: Vec<AccessibilityControlProperty>,
44	/// <https://schema.org/accessibilityFeature>
45	pub r#accessibility_feature: Vec<AccessibilityFeatureProperty>,
46	/// <https://schema.org/accessibilityHazard>
47	pub r#accessibility_hazard: Vec<AccessibilityHazardProperty>,
48	/// <https://schema.org/accessibilitySummary>
49	pub r#accessibility_summary: Vec<AccessibilitySummaryProperty>,
50	/// <https://schema.org/accountablePerson>
51	pub r#accountable_person: Vec<AccountablePersonProperty>,
52	/// <https://schema.org/acquireLicensePage>
53	pub r#acquire_license_page: Vec<AcquireLicensePageProperty>,
54	/// <https://schema.org/aggregateRating>
55	pub r#aggregate_rating: Vec<AggregateRatingProperty>,
56	/// <https://schema.org/alternativeHeadline>
57	pub r#alternative_headline: Vec<AlternativeHeadlineProperty>,
58	/// <https://schema.org/archivedAt>
59	pub r#archived_at: Vec<ArchivedAtProperty>,
60	/// <https://schema.org/assesses>
61	pub r#assesses: Vec<AssessesProperty>,
62	/// <https://schema.org/associatedMedia>
63	pub r#associated_media: Vec<AssociatedMediaProperty>,
64	/// <https://schema.org/audience>
65	pub r#audience: Vec<AudienceProperty>,
66	/// <https://schema.org/audio>
67	pub r#audio: Vec<AudioProperty>,
68	/// <https://schema.org/author>
69	pub r#author: Vec<AuthorProperty>,
70	/// <https://schema.org/award>
71	pub r#award: Vec<AwardProperty>,
72	/// <https://schema.org/awards>
73	#[deprecated = "This schema is superseded by <https://schema.org/award>."]
74	pub r#awards: Vec<AwardsProperty>,
75	/// <https://schema.org/character>
76	pub r#character: Vec<CharacterProperty>,
77	/// <https://schema.org/citation>
78	pub r#citation: Vec<CitationProperty>,
79	/// <https://schema.org/comment>
80	pub r#comment: Vec<CommentProperty>,
81	/// <https://schema.org/commentCount>
82	pub r#comment_count: Vec<CommentCountProperty>,
83	/// <https://schema.org/conditionsOfAccess>
84	pub r#conditions_of_access: Vec<ConditionsOfAccessProperty>,
85	/// <https://schema.org/contentLocation>
86	pub r#content_location: Vec<ContentLocationProperty>,
87	/// <https://schema.org/contentRating>
88	pub r#content_rating: Vec<ContentRatingProperty>,
89	/// <https://schema.org/contentReferenceTime>
90	pub r#content_reference_time: Vec<ContentReferenceTimeProperty>,
91	/// <https://schema.org/contributor>
92	pub r#contributor: Vec<ContributorProperty>,
93	/// <https://schema.org/copyrightHolder>
94	pub r#copyright_holder: Vec<CopyrightHolderProperty>,
95	/// <https://schema.org/copyrightNotice>
96	pub r#copyright_notice: Vec<CopyrightNoticeProperty>,
97	/// <https://schema.org/copyrightYear>
98	pub r#copyright_year: Vec<CopyrightYearProperty>,
99	/// <https://schema.org/correction>
100	pub r#correction: Vec<CorrectionProperty>,
101	/// <https://schema.org/countryOfOrigin>
102	pub r#country_of_origin: Vec<CountryOfOriginProperty>,
103	/// <https://schema.org/creativeWorkStatus>
104	pub r#creative_work_status: Vec<CreativeWorkStatusProperty>,
105	/// <https://schema.org/creator>
106	pub r#creator: Vec<CreatorProperty>,
107	/// <https://schema.org/creditText>
108	pub r#credit_text: Vec<CreditTextProperty>,
109	/// <https://schema.org/dateCreated>
110	pub r#date_created: Vec<DateCreatedProperty>,
111	/// <https://schema.org/dateModified>
112	pub r#date_modified: Vec<DateModifiedProperty>,
113	/// <https://schema.org/datePublished>
114	pub r#date_published: Vec<DatePublishedProperty>,
115	/// <https://schema.org/discussionUrl>
116	pub r#discussion_url: Vec<DiscussionUrlProperty>,
117	/// <https://schema.org/editEIDR>
118	pub r#edit_eidr: Vec<EditEidrProperty>,
119	/// <https://schema.org/editor>
120	pub r#editor: Vec<EditorProperty>,
121	/// <https://schema.org/educationalAlignment>
122	pub r#educational_alignment: Vec<EducationalAlignmentProperty>,
123	/// <https://schema.org/educationalLevel>
124	pub r#educational_level: Vec<EducationalLevelProperty>,
125	/// <https://schema.org/educationalUse>
126	pub r#educational_use: Vec<EducationalUseProperty>,
127	/// <https://schema.org/encoding>
128	pub r#encoding: Vec<EncodingProperty>,
129	/// <https://schema.org/encodingFormat>
130	pub r#encoding_format: Vec<EncodingFormatProperty>,
131	/// <https://schema.org/encodings>
132	#[deprecated = "This schema is superseded by <https://schema.org/encoding>."]
133	pub r#encodings: Vec<EncodingsProperty>,
134	/// <https://schema.org/exampleOfWork>
135	pub r#example_of_work: Vec<ExampleOfWorkProperty>,
136	/// <https://schema.org/expires>
137	pub r#expires: Vec<ExpiresProperty>,
138	/// <https://schema.org/fileFormat>
139	#[deprecated = "This schema is superseded by <https://schema.org/encodingFormat>."]
140	pub r#file_format: Vec<FileFormatProperty>,
141	/// <https://schema.org/funder>
142	pub r#funder: Vec<FunderProperty>,
143	/// <https://schema.org/funding>
144	pub r#funding: Vec<FundingProperty>,
145	/// <https://schema.org/genre>
146	pub r#genre: Vec<GenreProperty>,
147	/// <https://schema.org/hasPart>
148	pub r#has_part: Vec<HasPartProperty>,
149	/// <https://schema.org/headline>
150	pub r#headline: Vec<HeadlineProperty>,
151	/// <https://schema.org/inLanguage>
152	pub r#in_language: Vec<InLanguageProperty>,
153	/// <https://schema.org/interactionStatistic>
154	pub r#interaction_statistic: Vec<InteractionStatisticProperty>,
155	/// <https://schema.org/interactivityType>
156	pub r#interactivity_type: Vec<InteractivityTypeProperty>,
157	/// <https://schema.org/interpretedAsClaim>
158	pub r#interpreted_as_claim: Vec<InterpretedAsClaimProperty>,
159	/// <https://schema.org/isAccessibleForFree>
160	pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
161	/// <https://schema.org/isBasedOn>
162	pub r#is_based_on: Vec<IsBasedOnProperty>,
163	/// <https://schema.org/isBasedOnUrl>
164	#[deprecated = "This schema is superseded by <https://schema.org/isBasedOn>."]
165	pub r#is_based_on_url: Vec<IsBasedOnUrlProperty>,
166	/// <https://schema.org/isFamilyFriendly>
167	pub r#is_family_friendly: Vec<IsFamilyFriendlyProperty>,
168	/// <https://schema.org/isPartOf>
169	pub r#is_part_of: Vec<IsPartOfProperty>,
170	/// <https://schema.org/keywords>
171	pub r#keywords: Vec<KeywordsProperty>,
172	/// <https://schema.org/learningResourceType>
173	pub r#learning_resource_type: Vec<LearningResourceTypeProperty>,
174	/// <https://schema.org/license>
175	pub r#license: Vec<LicenseProperty>,
176	/// <https://schema.org/locationCreated>
177	pub r#location_created: Vec<LocationCreatedProperty>,
178	/// <https://schema.org/mainEntity>
179	pub r#main_entity: Vec<MainEntityProperty>,
180	/// <https://schema.org/maintainer>
181	pub r#maintainer: Vec<MaintainerProperty>,
182	/// <https://schema.org/material>
183	pub r#material: Vec<MaterialProperty>,
184	/// <https://schema.org/materialExtent>
185	pub r#material_extent: Vec<MaterialExtentProperty>,
186	/// <https://schema.org/mentions>
187	pub r#mentions: Vec<MentionsProperty>,
188	/// <https://schema.org/offers>
189	pub r#offers: Vec<OffersProperty>,
190	/// <https://schema.org/pattern>
191	pub r#pattern: Vec<PatternProperty>,
192	/// <https://schema.org/position>
193	pub r#position: Vec<PositionProperty>,
194	/// <https://schema.org/producer>
195	pub r#producer: Vec<ProducerProperty>,
196	/// <https://schema.org/provider>
197	pub r#provider: Vec<ProviderProperty>,
198	/// <https://schema.org/publication>
199	pub r#publication: Vec<PublicationProperty>,
200	/// <https://schema.org/publisher>
201	pub r#publisher: Vec<PublisherProperty>,
202	/// <https://schema.org/publisherImprint>
203	pub r#publisher_imprint: Vec<PublisherImprintProperty>,
204	/// <https://schema.org/publishingPrinciples>
205	pub r#publishing_principles: Vec<PublishingPrinciplesProperty>,
206	/// <https://schema.org/recordedAt>
207	pub r#recorded_at: Vec<RecordedAtProperty>,
208	/// <https://schema.org/releasedEvent>
209	pub r#released_event: Vec<ReleasedEventProperty>,
210	/// <https://schema.org/review>
211	pub r#review: Vec<ReviewProperty>,
212	/// <https://schema.org/reviews>
213	#[deprecated = "This schema is superseded by <https://schema.org/review>."]
214	pub r#reviews: Vec<ReviewsProperty>,
215	/// <https://schema.org/schemaVersion>
216	pub r#schema_version: Vec<SchemaVersionProperty>,
217	/// <https://schema.org/sdDatePublished>
218	pub r#sd_date_published: Vec<SdDatePublishedProperty>,
219	/// <https://schema.org/sdLicense>
220	pub r#sd_license: Vec<SdLicenseProperty>,
221	/// <https://schema.org/sdPublisher>
222	pub r#sd_publisher: Vec<SdPublisherProperty>,
223	/// <https://schema.org/size>
224	pub r#size: Vec<SizeProperty>,
225	/// <https://schema.org/sourceOrganization>
226	pub r#source_organization: Vec<SourceOrganizationProperty>,
227	/// <https://schema.org/spatial>
228	pub r#spatial: Vec<SpatialProperty>,
229	/// <https://schema.org/spatialCoverage>
230	pub r#spatial_coverage: Vec<SpatialCoverageProperty>,
231	/// <https://schema.org/sponsor>
232	pub r#sponsor: Vec<SponsorProperty>,
233	/// <https://schema.org/teaches>
234	pub r#teaches: Vec<TeachesProperty>,
235	/// <https://schema.org/temporal>
236	pub r#temporal: Vec<TemporalProperty>,
237	/// <https://schema.org/temporalCoverage>
238	pub r#temporal_coverage: Vec<TemporalCoverageProperty>,
239	/// <https://schema.org/text>
240	pub r#text: Vec<TextProperty>,
241	/// <https://schema.org/thumbnail>
242	pub r#thumbnail: Vec<ThumbnailProperty>,
243	/// <https://schema.org/thumbnailUrl>
244	pub r#thumbnail_url: Vec<ThumbnailUrlProperty>,
245	/// <https://schema.org/timeRequired>
246	pub r#time_required: Vec<TimeRequiredProperty>,
247	/// <https://schema.org/translationOfWork>
248	pub r#translation_of_work: Vec<TranslationOfWorkProperty>,
249	/// <https://schema.org/translator>
250	pub r#translator: Vec<TranslatorProperty>,
251	/// <https://schema.org/typicalAgeRange>
252	pub r#typical_age_range: Vec<TypicalAgeRangeProperty>,
253	/// <https://schema.org/usageInfo>
254	pub r#usage_info: Vec<UsageInfoProperty>,
255	/// <https://schema.org/version>
256	pub r#version: Vec<VersionProperty>,
257	/// <https://schema.org/video>
258	pub r#video: Vec<VideoProperty>,
259	/// <https://schema.org/workExample>
260	pub r#work_example: Vec<WorkExampleProperty>,
261	/// <https://schema.org/workTranslation>
262	pub r#work_translation: Vec<WorkTranslationProperty>,
263	/// <https://schema.org/characterAttribute>
264	pub r#character_attribute: Vec<CharacterAttributeProperty>,
265	/// <https://schema.org/gameItem>
266	pub r#game_item: Vec<GameItemProperty>,
267	/// <https://schema.org/gameLocation>
268	pub r#game_location: Vec<GameLocationProperty>,
269	/// <https://schema.org/numberOfPlayers>
270	pub r#number_of_players: Vec<NumberOfPlayersProperty>,
271	/// <https://schema.org/quest>
272	pub r#quest: Vec<QuestProperty>,
273	/// <https://schema.org/applicationCategory>
274	pub r#application_category: Vec<ApplicationCategoryProperty>,
275	/// <https://schema.org/applicationSubCategory>
276	pub r#application_sub_category: Vec<ApplicationSubCategoryProperty>,
277	/// <https://schema.org/applicationSuite>
278	pub r#application_suite: Vec<ApplicationSuiteProperty>,
279	/// <https://schema.org/availableOnDevice>
280	pub r#available_on_device: Vec<AvailableOnDeviceProperty>,
281	/// <https://schema.org/countriesNotSupported>
282	pub r#countries_not_supported: Vec<CountriesNotSupportedProperty>,
283	/// <https://schema.org/countriesSupported>
284	pub r#countries_supported: Vec<CountriesSupportedProperty>,
285	/// <https://schema.org/device>
286	#[deprecated = "This schema is superseded by <https://schema.org/availableOnDevice>."]
287	pub r#device: Vec<DeviceProperty>,
288	/// <https://schema.org/downloadUrl>
289	pub r#download_url: Vec<DownloadUrlProperty>,
290	/// <https://schema.org/featureList>
291	pub r#feature_list: Vec<FeatureListProperty>,
292	/// <https://schema.org/fileSize>
293	pub r#file_size: Vec<FileSizeProperty>,
294	/// <https://schema.org/installUrl>
295	pub r#install_url: Vec<InstallUrlProperty>,
296	/// <https://schema.org/memoryRequirements>
297	pub r#memory_requirements: Vec<MemoryRequirementsProperty>,
298	/// <https://schema.org/operatingSystem>
299	pub r#operating_system: Vec<OperatingSystemProperty>,
300	/// <https://schema.org/permissions>
301	pub r#permissions: Vec<PermissionsProperty>,
302	/// <https://schema.org/processorRequirements>
303	pub r#processor_requirements: Vec<ProcessorRequirementsProperty>,
304	/// <https://schema.org/releaseNotes>
305	pub r#release_notes: Vec<ReleaseNotesProperty>,
306	/// <https://schema.org/requirements>
307	#[deprecated = "This schema is superseded by <https://schema.org/softwareRequirements>."]
308	pub r#requirements: Vec<RequirementsProperty>,
309	/// <https://schema.org/screenshot>
310	pub r#screenshot: Vec<ScreenshotProperty>,
311	/// <https://schema.org/softwareAddOn>
312	pub r#software_add_on: Vec<SoftwareAddOnProperty>,
313	/// <https://schema.org/softwareHelp>
314	pub r#software_help: Vec<SoftwareHelpProperty>,
315	/// <https://schema.org/softwareRequirements>
316	pub r#software_requirements: Vec<SoftwareRequirementsProperty>,
317	/// <https://schema.org/softwareVersion>
318	pub r#software_version: Vec<SoftwareVersionProperty>,
319	/// <https://schema.org/storageRequirements>
320	pub r#storage_requirements: Vec<StorageRequirementsProperty>,
321	/// <https://schema.org/supportingData>
322	pub r#supporting_data: Vec<SupportingDataProperty>,
323	/// <https://schema.org/additionalType>
324	pub r#additional_type: Vec<AdditionalTypeProperty>,
325	/// <https://schema.org/alternateName>
326	pub r#alternate_name: Vec<AlternateNameProperty>,
327	/// <https://schema.org/description>
328	pub r#description: Vec<DescriptionProperty>,
329	/// <https://schema.org/disambiguatingDescription>
330	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
331	/// <https://schema.org/identifier>
332	pub r#identifier: Vec<IdentifierProperty>,
333	/// <https://schema.org/image>
334	pub r#image: Vec<ImageProperty>,
335	/// <https://schema.org/mainEntityOfPage>
336	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
337	/// <https://schema.org/name>
338	pub r#name: Vec<NameProperty>,
339	/// <https://schema.org/potentialAction>
340	pub r#potential_action: Vec<PotentialActionProperty>,
341	/// <https://schema.org/sameAs>
342	pub r#same_as: Vec<SameAsProperty>,
343	/// <https://schema.org/subjectOf>
344	pub r#subject_of: Vec<SubjectOfProperty>,
345	/// <https://schema.org/url>
346	pub r#url: Vec<UrlProperty>,
347}
348/// This trait is for properties from <https://schema.org/VideoGame>.
349pub trait VideoGameTrait {
350	/// Get <https://schema.org/actor> from [`Self`] as borrowed slice.
351	fn get_actor(&self) -> &[ActorProperty];
352	/// Take <https://schema.org/actor> from [`Self`] as owned vector.
353	fn take_actor(&mut self) -> Vec<ActorProperty>;
354	/// Get <https://schema.org/actors> from [`Self`] as borrowed slice.
355	#[deprecated = "This schema is superseded by <https://schema.org/actor>."]
356	fn get_actors(&self) -> &[ActorsProperty];
357	/// Take <https://schema.org/actors> from [`Self`] as owned vector.
358	#[deprecated = "This schema is superseded by <https://schema.org/actor>."]
359	fn take_actors(&mut self) -> Vec<ActorsProperty>;
360	/// Get <https://schema.org/cheatCode> from [`Self`] as borrowed slice.
361	fn get_cheat_code(&self) -> &[CheatCodeProperty];
362	/// Take <https://schema.org/cheatCode> from [`Self`] as owned vector.
363	fn take_cheat_code(&mut self) -> Vec<CheatCodeProperty>;
364	/// Get <https://schema.org/director> from [`Self`] as borrowed slice.
365	fn get_director(&self) -> &[DirectorProperty];
366	/// Take <https://schema.org/director> from [`Self`] as owned vector.
367	fn take_director(&mut self) -> Vec<DirectorProperty>;
368	/// Get <https://schema.org/directors> from [`Self`] as borrowed slice.
369	#[deprecated = "This schema is superseded by <https://schema.org/director>."]
370	fn get_directors(&self) -> &[DirectorsProperty];
371	/// Take <https://schema.org/directors> from [`Self`] as owned vector.
372	#[deprecated = "This schema is superseded by <https://schema.org/director>."]
373	fn take_directors(&mut self) -> Vec<DirectorsProperty>;
374	/// Get <https://schema.org/gameEdition> from [`Self`] as borrowed slice.
375	fn get_game_edition(&self) -> &[GameEditionProperty];
376	/// Take <https://schema.org/gameEdition> from [`Self`] as owned vector.
377	fn take_game_edition(&mut self) -> Vec<GameEditionProperty>;
378	/// Get <https://schema.org/gamePlatform> from [`Self`] as borrowed slice.
379	fn get_game_platform(&self) -> &[GamePlatformProperty];
380	/// Take <https://schema.org/gamePlatform> from [`Self`] as owned vector.
381	fn take_game_platform(&mut self) -> Vec<GamePlatformProperty>;
382	/// Get <https://schema.org/gameServer> from [`Self`] as borrowed slice.
383	fn get_game_server(&self) -> &[GameServerProperty];
384	/// Take <https://schema.org/gameServer> from [`Self`] as owned vector.
385	fn take_game_server(&mut self) -> Vec<GameServerProperty>;
386	/// Get <https://schema.org/gameTip> from [`Self`] as borrowed slice.
387	fn get_game_tip(&self) -> &[GameTipProperty];
388	/// Take <https://schema.org/gameTip> from [`Self`] as owned vector.
389	fn take_game_tip(&mut self) -> Vec<GameTipProperty>;
390	/// Get <https://schema.org/musicBy> from [`Self`] as borrowed slice.
391	fn get_music_by(&self) -> &[MusicByProperty];
392	/// Take <https://schema.org/musicBy> from [`Self`] as owned vector.
393	fn take_music_by(&mut self) -> Vec<MusicByProperty>;
394	/// Get <https://schema.org/playMode> from [`Self`] as borrowed slice.
395	fn get_play_mode(&self) -> &[PlayModeProperty];
396	/// Take <https://schema.org/playMode> from [`Self`] as owned vector.
397	fn take_play_mode(&mut self) -> Vec<PlayModeProperty>;
398	/// Get <https://schema.org/trailer> from [`Self`] as borrowed slice.
399	fn get_trailer(&self) -> &[TrailerProperty];
400	/// Take <https://schema.org/trailer> from [`Self`] as owned vector.
401	fn take_trailer(&mut self) -> Vec<TrailerProperty>;
402}
403impl VideoGameTrait for VideoGame {
404	fn get_actor(&self) -> &[ActorProperty] {
405		self.r#actor.as_slice()
406	}
407	fn take_actor(&mut self) -> Vec<ActorProperty> {
408		std::mem::take(&mut self.r#actor)
409	}
410	fn get_actors(&self) -> &[ActorsProperty] {
411		self.r#actors.as_slice()
412	}
413	fn take_actors(&mut self) -> Vec<ActorsProperty> {
414		std::mem::take(&mut self.r#actors)
415	}
416	fn get_cheat_code(&self) -> &[CheatCodeProperty] {
417		self.r#cheat_code.as_slice()
418	}
419	fn take_cheat_code(&mut self) -> Vec<CheatCodeProperty> {
420		std::mem::take(&mut self.r#cheat_code)
421	}
422	fn get_director(&self) -> &[DirectorProperty] {
423		self.r#director.as_slice()
424	}
425	fn take_director(&mut self) -> Vec<DirectorProperty> {
426		std::mem::take(&mut self.r#director)
427	}
428	fn get_directors(&self) -> &[DirectorsProperty] {
429		self.r#directors.as_slice()
430	}
431	fn take_directors(&mut self) -> Vec<DirectorsProperty> {
432		std::mem::take(&mut self.r#directors)
433	}
434	fn get_game_edition(&self) -> &[GameEditionProperty] {
435		self.r#game_edition.as_slice()
436	}
437	fn take_game_edition(&mut self) -> Vec<GameEditionProperty> {
438		std::mem::take(&mut self.r#game_edition)
439	}
440	fn get_game_platform(&self) -> &[GamePlatformProperty] {
441		self.r#game_platform.as_slice()
442	}
443	fn take_game_platform(&mut self) -> Vec<GamePlatformProperty> {
444		std::mem::take(&mut self.r#game_platform)
445	}
446	fn get_game_server(&self) -> &[GameServerProperty] {
447		self.r#game_server.as_slice()
448	}
449	fn take_game_server(&mut self) -> Vec<GameServerProperty> {
450		std::mem::take(&mut self.r#game_server)
451	}
452	fn get_game_tip(&self) -> &[GameTipProperty] {
453		self.r#game_tip.as_slice()
454	}
455	fn take_game_tip(&mut self) -> Vec<GameTipProperty> {
456		std::mem::take(&mut self.r#game_tip)
457	}
458	fn get_music_by(&self) -> &[MusicByProperty] {
459		self.r#music_by.as_slice()
460	}
461	fn take_music_by(&mut self) -> Vec<MusicByProperty> {
462		std::mem::take(&mut self.r#music_by)
463	}
464	fn get_play_mode(&self) -> &[PlayModeProperty] {
465		self.r#play_mode.as_slice()
466	}
467	fn take_play_mode(&mut self) -> Vec<PlayModeProperty> {
468		std::mem::take(&mut self.r#play_mode)
469	}
470	fn get_trailer(&self) -> &[TrailerProperty] {
471		self.r#trailer.as_slice()
472	}
473	fn take_trailer(&mut self) -> Vec<TrailerProperty> {
474		std::mem::take(&mut self.r#trailer)
475	}
476}
477impl CreativeWorkTrait for VideoGame {
478	fn get_about(&self) -> &[AboutProperty] {
479		self.r#about.as_slice()
480	}
481	fn take_about(&mut self) -> Vec<AboutProperty> {
482		std::mem::take(&mut self.r#about)
483	}
484	fn get_abstract(&self) -> &[AbstractProperty] {
485		self.r#abstract.as_slice()
486	}
487	fn take_abstract(&mut self) -> Vec<AbstractProperty> {
488		std::mem::take(&mut self.r#abstract)
489	}
490	fn get_access_mode(&self) -> &[AccessModeProperty] {
491		self.r#access_mode.as_slice()
492	}
493	fn take_access_mode(&mut self) -> Vec<AccessModeProperty> {
494		std::mem::take(&mut self.r#access_mode)
495	}
496	fn get_access_mode_sufficient(&self) -> &[AccessModeSufficientProperty] {
497		self.r#access_mode_sufficient.as_slice()
498	}
499	fn take_access_mode_sufficient(&mut self) -> Vec<AccessModeSufficientProperty> {
500		std::mem::take(&mut self.r#access_mode_sufficient)
501	}
502	fn get_accessibility_api(&self) -> &[AccessibilityApiProperty] {
503		self.r#accessibility_api.as_slice()
504	}
505	fn take_accessibility_api(&mut self) -> Vec<AccessibilityApiProperty> {
506		std::mem::take(&mut self.r#accessibility_api)
507	}
508	fn get_accessibility_control(&self) -> &[AccessibilityControlProperty] {
509		self.r#accessibility_control.as_slice()
510	}
511	fn take_accessibility_control(&mut self) -> Vec<AccessibilityControlProperty> {
512		std::mem::take(&mut self.r#accessibility_control)
513	}
514	fn get_accessibility_feature(&self) -> &[AccessibilityFeatureProperty] {
515		self.r#accessibility_feature.as_slice()
516	}
517	fn take_accessibility_feature(&mut self) -> Vec<AccessibilityFeatureProperty> {
518		std::mem::take(&mut self.r#accessibility_feature)
519	}
520	fn get_accessibility_hazard(&self) -> &[AccessibilityHazardProperty] {
521		self.r#accessibility_hazard.as_slice()
522	}
523	fn take_accessibility_hazard(&mut self) -> Vec<AccessibilityHazardProperty> {
524		std::mem::take(&mut self.r#accessibility_hazard)
525	}
526	fn get_accessibility_summary(&self) -> &[AccessibilitySummaryProperty] {
527		self.r#accessibility_summary.as_slice()
528	}
529	fn take_accessibility_summary(&mut self) -> Vec<AccessibilitySummaryProperty> {
530		std::mem::take(&mut self.r#accessibility_summary)
531	}
532	fn get_accountable_person(&self) -> &[AccountablePersonProperty] {
533		self.r#accountable_person.as_slice()
534	}
535	fn take_accountable_person(&mut self) -> Vec<AccountablePersonProperty> {
536		std::mem::take(&mut self.r#accountable_person)
537	}
538	fn get_acquire_license_page(&self) -> &[AcquireLicensePageProperty] {
539		self.r#acquire_license_page.as_slice()
540	}
541	fn take_acquire_license_page(&mut self) -> Vec<AcquireLicensePageProperty> {
542		std::mem::take(&mut self.r#acquire_license_page)
543	}
544	fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
545		self.r#aggregate_rating.as_slice()
546	}
547	fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
548		std::mem::take(&mut self.r#aggregate_rating)
549	}
550	fn get_alternative_headline(&self) -> &[AlternativeHeadlineProperty] {
551		self.r#alternative_headline.as_slice()
552	}
553	fn take_alternative_headline(&mut self) -> Vec<AlternativeHeadlineProperty> {
554		std::mem::take(&mut self.r#alternative_headline)
555	}
556	fn get_archived_at(&self) -> &[ArchivedAtProperty] {
557		self.r#archived_at.as_slice()
558	}
559	fn take_archived_at(&mut self) -> Vec<ArchivedAtProperty> {
560		std::mem::take(&mut self.r#archived_at)
561	}
562	fn get_assesses(&self) -> &[AssessesProperty] {
563		self.r#assesses.as_slice()
564	}
565	fn take_assesses(&mut self) -> Vec<AssessesProperty> {
566		std::mem::take(&mut self.r#assesses)
567	}
568	fn get_associated_media(&self) -> &[AssociatedMediaProperty] {
569		self.r#associated_media.as_slice()
570	}
571	fn take_associated_media(&mut self) -> Vec<AssociatedMediaProperty> {
572		std::mem::take(&mut self.r#associated_media)
573	}
574	fn get_audience(&self) -> &[AudienceProperty] {
575		self.r#audience.as_slice()
576	}
577	fn take_audience(&mut self) -> Vec<AudienceProperty> {
578		std::mem::take(&mut self.r#audience)
579	}
580	fn get_audio(&self) -> &[AudioProperty] {
581		self.r#audio.as_slice()
582	}
583	fn take_audio(&mut self) -> Vec<AudioProperty> {
584		std::mem::take(&mut self.r#audio)
585	}
586	fn get_author(&self) -> &[AuthorProperty] {
587		self.r#author.as_slice()
588	}
589	fn take_author(&mut self) -> Vec<AuthorProperty> {
590		std::mem::take(&mut self.r#author)
591	}
592	fn get_award(&self) -> &[AwardProperty] {
593		self.r#award.as_slice()
594	}
595	fn take_award(&mut self) -> Vec<AwardProperty> {
596		std::mem::take(&mut self.r#award)
597	}
598	fn get_awards(&self) -> &[AwardsProperty] {
599		self.r#awards.as_slice()
600	}
601	fn take_awards(&mut self) -> Vec<AwardsProperty> {
602		std::mem::take(&mut self.r#awards)
603	}
604	fn get_character(&self) -> &[CharacterProperty] {
605		self.r#character.as_slice()
606	}
607	fn take_character(&mut self) -> Vec<CharacterProperty> {
608		std::mem::take(&mut self.r#character)
609	}
610	fn get_citation(&self) -> &[CitationProperty] {
611		self.r#citation.as_slice()
612	}
613	fn take_citation(&mut self) -> Vec<CitationProperty> {
614		std::mem::take(&mut self.r#citation)
615	}
616	fn get_comment(&self) -> &[CommentProperty] {
617		self.r#comment.as_slice()
618	}
619	fn take_comment(&mut self) -> Vec<CommentProperty> {
620		std::mem::take(&mut self.r#comment)
621	}
622	fn get_comment_count(&self) -> &[CommentCountProperty] {
623		self.r#comment_count.as_slice()
624	}
625	fn take_comment_count(&mut self) -> Vec<CommentCountProperty> {
626		std::mem::take(&mut self.r#comment_count)
627	}
628	fn get_conditions_of_access(&self) -> &[ConditionsOfAccessProperty] {
629		self.r#conditions_of_access.as_slice()
630	}
631	fn take_conditions_of_access(&mut self) -> Vec<ConditionsOfAccessProperty> {
632		std::mem::take(&mut self.r#conditions_of_access)
633	}
634	fn get_content_location(&self) -> &[ContentLocationProperty] {
635		self.r#content_location.as_slice()
636	}
637	fn take_content_location(&mut self) -> Vec<ContentLocationProperty> {
638		std::mem::take(&mut self.r#content_location)
639	}
640	fn get_content_rating(&self) -> &[ContentRatingProperty] {
641		self.r#content_rating.as_slice()
642	}
643	fn take_content_rating(&mut self) -> Vec<ContentRatingProperty> {
644		std::mem::take(&mut self.r#content_rating)
645	}
646	fn get_content_reference_time(&self) -> &[ContentReferenceTimeProperty] {
647		self.r#content_reference_time.as_slice()
648	}
649	fn take_content_reference_time(&mut self) -> Vec<ContentReferenceTimeProperty> {
650		std::mem::take(&mut self.r#content_reference_time)
651	}
652	fn get_contributor(&self) -> &[ContributorProperty] {
653		self.r#contributor.as_slice()
654	}
655	fn take_contributor(&mut self) -> Vec<ContributorProperty> {
656		std::mem::take(&mut self.r#contributor)
657	}
658	fn get_copyright_holder(&self) -> &[CopyrightHolderProperty] {
659		self.r#copyright_holder.as_slice()
660	}
661	fn take_copyright_holder(&mut self) -> Vec<CopyrightHolderProperty> {
662		std::mem::take(&mut self.r#copyright_holder)
663	}
664	fn get_copyright_notice(&self) -> &[CopyrightNoticeProperty] {
665		self.r#copyright_notice.as_slice()
666	}
667	fn take_copyright_notice(&mut self) -> Vec<CopyrightNoticeProperty> {
668		std::mem::take(&mut self.r#copyright_notice)
669	}
670	fn get_copyright_year(&self) -> &[CopyrightYearProperty] {
671		self.r#copyright_year.as_slice()
672	}
673	fn take_copyright_year(&mut self) -> Vec<CopyrightYearProperty> {
674		std::mem::take(&mut self.r#copyright_year)
675	}
676	fn get_correction(&self) -> &[CorrectionProperty] {
677		self.r#correction.as_slice()
678	}
679	fn take_correction(&mut self) -> Vec<CorrectionProperty> {
680		std::mem::take(&mut self.r#correction)
681	}
682	fn get_country_of_origin(&self) -> &[CountryOfOriginProperty] {
683		self.r#country_of_origin.as_slice()
684	}
685	fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty> {
686		std::mem::take(&mut self.r#country_of_origin)
687	}
688	fn get_creative_work_status(&self) -> &[CreativeWorkStatusProperty] {
689		self.r#creative_work_status.as_slice()
690	}
691	fn take_creative_work_status(&mut self) -> Vec<CreativeWorkStatusProperty> {
692		std::mem::take(&mut self.r#creative_work_status)
693	}
694	fn get_creator(&self) -> &[CreatorProperty] {
695		self.r#creator.as_slice()
696	}
697	fn take_creator(&mut self) -> Vec<CreatorProperty> {
698		std::mem::take(&mut self.r#creator)
699	}
700	fn get_credit_text(&self) -> &[CreditTextProperty] {
701		self.r#credit_text.as_slice()
702	}
703	fn take_credit_text(&mut self) -> Vec<CreditTextProperty> {
704		std::mem::take(&mut self.r#credit_text)
705	}
706	fn get_date_created(&self) -> &[DateCreatedProperty] {
707		self.r#date_created.as_slice()
708	}
709	fn take_date_created(&mut self) -> Vec<DateCreatedProperty> {
710		std::mem::take(&mut self.r#date_created)
711	}
712	fn get_date_modified(&self) -> &[DateModifiedProperty] {
713		self.r#date_modified.as_slice()
714	}
715	fn take_date_modified(&mut self) -> Vec<DateModifiedProperty> {
716		std::mem::take(&mut self.r#date_modified)
717	}
718	fn get_date_published(&self) -> &[DatePublishedProperty] {
719		self.r#date_published.as_slice()
720	}
721	fn take_date_published(&mut self) -> Vec<DatePublishedProperty> {
722		std::mem::take(&mut self.r#date_published)
723	}
724	fn get_discussion_url(&self) -> &[DiscussionUrlProperty] {
725		self.r#discussion_url.as_slice()
726	}
727	fn take_discussion_url(&mut self) -> Vec<DiscussionUrlProperty> {
728		std::mem::take(&mut self.r#discussion_url)
729	}
730	fn get_edit_eidr(&self) -> &[EditEidrProperty] {
731		self.r#edit_eidr.as_slice()
732	}
733	fn take_edit_eidr(&mut self) -> Vec<EditEidrProperty> {
734		std::mem::take(&mut self.r#edit_eidr)
735	}
736	fn get_editor(&self) -> &[EditorProperty] {
737		self.r#editor.as_slice()
738	}
739	fn take_editor(&mut self) -> Vec<EditorProperty> {
740		std::mem::take(&mut self.r#editor)
741	}
742	fn get_educational_alignment(&self) -> &[EducationalAlignmentProperty] {
743		self.r#educational_alignment.as_slice()
744	}
745	fn take_educational_alignment(&mut self) -> Vec<EducationalAlignmentProperty> {
746		std::mem::take(&mut self.r#educational_alignment)
747	}
748	fn get_educational_level(&self) -> &[EducationalLevelProperty] {
749		self.r#educational_level.as_slice()
750	}
751	fn take_educational_level(&mut self) -> Vec<EducationalLevelProperty> {
752		std::mem::take(&mut self.r#educational_level)
753	}
754	fn get_educational_use(&self) -> &[EducationalUseProperty] {
755		self.r#educational_use.as_slice()
756	}
757	fn take_educational_use(&mut self) -> Vec<EducationalUseProperty> {
758		std::mem::take(&mut self.r#educational_use)
759	}
760	fn get_encoding(&self) -> &[EncodingProperty] {
761		self.r#encoding.as_slice()
762	}
763	fn take_encoding(&mut self) -> Vec<EncodingProperty> {
764		std::mem::take(&mut self.r#encoding)
765	}
766	fn get_encoding_format(&self) -> &[EncodingFormatProperty] {
767		self.r#encoding_format.as_slice()
768	}
769	fn take_encoding_format(&mut self) -> Vec<EncodingFormatProperty> {
770		std::mem::take(&mut self.r#encoding_format)
771	}
772	fn get_encodings(&self) -> &[EncodingsProperty] {
773		self.r#encodings.as_slice()
774	}
775	fn take_encodings(&mut self) -> Vec<EncodingsProperty> {
776		std::mem::take(&mut self.r#encodings)
777	}
778	fn get_example_of_work(&self) -> &[ExampleOfWorkProperty] {
779		self.r#example_of_work.as_slice()
780	}
781	fn take_example_of_work(&mut self) -> Vec<ExampleOfWorkProperty> {
782		std::mem::take(&mut self.r#example_of_work)
783	}
784	fn get_expires(&self) -> &[ExpiresProperty] {
785		self.r#expires.as_slice()
786	}
787	fn take_expires(&mut self) -> Vec<ExpiresProperty> {
788		std::mem::take(&mut self.r#expires)
789	}
790	fn get_file_format(&self) -> &[FileFormatProperty] {
791		self.r#file_format.as_slice()
792	}
793	fn take_file_format(&mut self) -> Vec<FileFormatProperty> {
794		std::mem::take(&mut self.r#file_format)
795	}
796	fn get_funder(&self) -> &[FunderProperty] {
797		self.r#funder.as_slice()
798	}
799	fn take_funder(&mut self) -> Vec<FunderProperty> {
800		std::mem::take(&mut self.r#funder)
801	}
802	fn get_funding(&self) -> &[FundingProperty] {
803		self.r#funding.as_slice()
804	}
805	fn take_funding(&mut self) -> Vec<FundingProperty> {
806		std::mem::take(&mut self.r#funding)
807	}
808	fn get_genre(&self) -> &[GenreProperty] {
809		self.r#genre.as_slice()
810	}
811	fn take_genre(&mut self) -> Vec<GenreProperty> {
812		std::mem::take(&mut self.r#genre)
813	}
814	fn get_has_part(&self) -> &[HasPartProperty] {
815		self.r#has_part.as_slice()
816	}
817	fn take_has_part(&mut self) -> Vec<HasPartProperty> {
818		std::mem::take(&mut self.r#has_part)
819	}
820	fn get_headline(&self) -> &[HeadlineProperty] {
821		self.r#headline.as_slice()
822	}
823	fn take_headline(&mut self) -> Vec<HeadlineProperty> {
824		std::mem::take(&mut self.r#headline)
825	}
826	fn get_in_language(&self) -> &[InLanguageProperty] {
827		self.r#in_language.as_slice()
828	}
829	fn take_in_language(&mut self) -> Vec<InLanguageProperty> {
830		std::mem::take(&mut self.r#in_language)
831	}
832	fn get_interaction_statistic(&self) -> &[InteractionStatisticProperty] {
833		self.r#interaction_statistic.as_slice()
834	}
835	fn take_interaction_statistic(&mut self) -> Vec<InteractionStatisticProperty> {
836		std::mem::take(&mut self.r#interaction_statistic)
837	}
838	fn get_interactivity_type(&self) -> &[InteractivityTypeProperty] {
839		self.r#interactivity_type.as_slice()
840	}
841	fn take_interactivity_type(&mut self) -> Vec<InteractivityTypeProperty> {
842		std::mem::take(&mut self.r#interactivity_type)
843	}
844	fn get_interpreted_as_claim(&self) -> &[InterpretedAsClaimProperty] {
845		self.r#interpreted_as_claim.as_slice()
846	}
847	fn take_interpreted_as_claim(&mut self) -> Vec<InterpretedAsClaimProperty> {
848		std::mem::take(&mut self.r#interpreted_as_claim)
849	}
850	fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
851		self.r#is_accessible_for_free.as_slice()
852	}
853	fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
854		std::mem::take(&mut self.r#is_accessible_for_free)
855	}
856	fn get_is_based_on(&self) -> &[IsBasedOnProperty] {
857		self.r#is_based_on.as_slice()
858	}
859	fn take_is_based_on(&mut self) -> Vec<IsBasedOnProperty> {
860		std::mem::take(&mut self.r#is_based_on)
861	}
862	fn get_is_based_on_url(&self) -> &[IsBasedOnUrlProperty] {
863		self.r#is_based_on_url.as_slice()
864	}
865	fn take_is_based_on_url(&mut self) -> Vec<IsBasedOnUrlProperty> {
866		std::mem::take(&mut self.r#is_based_on_url)
867	}
868	fn get_is_family_friendly(&self) -> &[IsFamilyFriendlyProperty] {
869		self.r#is_family_friendly.as_slice()
870	}
871	fn take_is_family_friendly(&mut self) -> Vec<IsFamilyFriendlyProperty> {
872		std::mem::take(&mut self.r#is_family_friendly)
873	}
874	fn get_is_part_of(&self) -> &[IsPartOfProperty] {
875		self.r#is_part_of.as_slice()
876	}
877	fn take_is_part_of(&mut self) -> Vec<IsPartOfProperty> {
878		std::mem::take(&mut self.r#is_part_of)
879	}
880	fn get_keywords(&self) -> &[KeywordsProperty] {
881		self.r#keywords.as_slice()
882	}
883	fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
884		std::mem::take(&mut self.r#keywords)
885	}
886	fn get_learning_resource_type(&self) -> &[LearningResourceTypeProperty] {
887		self.r#learning_resource_type.as_slice()
888	}
889	fn take_learning_resource_type(&mut self) -> Vec<LearningResourceTypeProperty> {
890		std::mem::take(&mut self.r#learning_resource_type)
891	}
892	fn get_license(&self) -> &[LicenseProperty] {
893		self.r#license.as_slice()
894	}
895	fn take_license(&mut self) -> Vec<LicenseProperty> {
896		std::mem::take(&mut self.r#license)
897	}
898	fn get_location_created(&self) -> &[LocationCreatedProperty] {
899		self.r#location_created.as_slice()
900	}
901	fn take_location_created(&mut self) -> Vec<LocationCreatedProperty> {
902		std::mem::take(&mut self.r#location_created)
903	}
904	fn get_main_entity(&self) -> &[MainEntityProperty] {
905		self.r#main_entity.as_slice()
906	}
907	fn take_main_entity(&mut self) -> Vec<MainEntityProperty> {
908		std::mem::take(&mut self.r#main_entity)
909	}
910	fn get_maintainer(&self) -> &[MaintainerProperty] {
911		self.r#maintainer.as_slice()
912	}
913	fn take_maintainer(&mut self) -> Vec<MaintainerProperty> {
914		std::mem::take(&mut self.r#maintainer)
915	}
916	fn get_material(&self) -> &[MaterialProperty] {
917		self.r#material.as_slice()
918	}
919	fn take_material(&mut self) -> Vec<MaterialProperty> {
920		std::mem::take(&mut self.r#material)
921	}
922	fn get_material_extent(&self) -> &[MaterialExtentProperty] {
923		self.r#material_extent.as_slice()
924	}
925	fn take_material_extent(&mut self) -> Vec<MaterialExtentProperty> {
926		std::mem::take(&mut self.r#material_extent)
927	}
928	fn get_mentions(&self) -> &[MentionsProperty] {
929		self.r#mentions.as_slice()
930	}
931	fn take_mentions(&mut self) -> Vec<MentionsProperty> {
932		std::mem::take(&mut self.r#mentions)
933	}
934	fn get_offers(&self) -> &[OffersProperty] {
935		self.r#offers.as_slice()
936	}
937	fn take_offers(&mut self) -> Vec<OffersProperty> {
938		std::mem::take(&mut self.r#offers)
939	}
940	fn get_pattern(&self) -> &[PatternProperty] {
941		self.r#pattern.as_slice()
942	}
943	fn take_pattern(&mut self) -> Vec<PatternProperty> {
944		std::mem::take(&mut self.r#pattern)
945	}
946	fn get_position(&self) -> &[PositionProperty] {
947		self.r#position.as_slice()
948	}
949	fn take_position(&mut self) -> Vec<PositionProperty> {
950		std::mem::take(&mut self.r#position)
951	}
952	fn get_producer(&self) -> &[ProducerProperty] {
953		self.r#producer.as_slice()
954	}
955	fn take_producer(&mut self) -> Vec<ProducerProperty> {
956		std::mem::take(&mut self.r#producer)
957	}
958	fn get_provider(&self) -> &[ProviderProperty] {
959		self.r#provider.as_slice()
960	}
961	fn take_provider(&mut self) -> Vec<ProviderProperty> {
962		std::mem::take(&mut self.r#provider)
963	}
964	fn get_publication(&self) -> &[PublicationProperty] {
965		self.r#publication.as_slice()
966	}
967	fn take_publication(&mut self) -> Vec<PublicationProperty> {
968		std::mem::take(&mut self.r#publication)
969	}
970	fn get_publisher(&self) -> &[PublisherProperty] {
971		self.r#publisher.as_slice()
972	}
973	fn take_publisher(&mut self) -> Vec<PublisherProperty> {
974		std::mem::take(&mut self.r#publisher)
975	}
976	fn get_publisher_imprint(&self) -> &[PublisherImprintProperty] {
977		self.r#publisher_imprint.as_slice()
978	}
979	fn take_publisher_imprint(&mut self) -> Vec<PublisherImprintProperty> {
980		std::mem::take(&mut self.r#publisher_imprint)
981	}
982	fn get_publishing_principles(&self) -> &[PublishingPrinciplesProperty] {
983		self.r#publishing_principles.as_slice()
984	}
985	fn take_publishing_principles(&mut self) -> Vec<PublishingPrinciplesProperty> {
986		std::mem::take(&mut self.r#publishing_principles)
987	}
988	fn get_recorded_at(&self) -> &[RecordedAtProperty] {
989		self.r#recorded_at.as_slice()
990	}
991	fn take_recorded_at(&mut self) -> Vec<RecordedAtProperty> {
992		std::mem::take(&mut self.r#recorded_at)
993	}
994	fn get_released_event(&self) -> &[ReleasedEventProperty] {
995		self.r#released_event.as_slice()
996	}
997	fn take_released_event(&mut self) -> Vec<ReleasedEventProperty> {
998		std::mem::take(&mut self.r#released_event)
999	}
1000	fn get_review(&self) -> &[ReviewProperty] {
1001		self.r#review.as_slice()
1002	}
1003	fn take_review(&mut self) -> Vec<ReviewProperty> {
1004		std::mem::take(&mut self.r#review)
1005	}
1006	fn get_reviews(&self) -> &[ReviewsProperty] {
1007		self.r#reviews.as_slice()
1008	}
1009	fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
1010		std::mem::take(&mut self.r#reviews)
1011	}
1012	fn get_schema_version(&self) -> &[SchemaVersionProperty] {
1013		self.r#schema_version.as_slice()
1014	}
1015	fn take_schema_version(&mut self) -> Vec<SchemaVersionProperty> {
1016		std::mem::take(&mut self.r#schema_version)
1017	}
1018	fn get_sd_date_published(&self) -> &[SdDatePublishedProperty] {
1019		self.r#sd_date_published.as_slice()
1020	}
1021	fn take_sd_date_published(&mut self) -> Vec<SdDatePublishedProperty> {
1022		std::mem::take(&mut self.r#sd_date_published)
1023	}
1024	fn get_sd_license(&self) -> &[SdLicenseProperty] {
1025		self.r#sd_license.as_slice()
1026	}
1027	fn take_sd_license(&mut self) -> Vec<SdLicenseProperty> {
1028		std::mem::take(&mut self.r#sd_license)
1029	}
1030	fn get_sd_publisher(&self) -> &[SdPublisherProperty] {
1031		self.r#sd_publisher.as_slice()
1032	}
1033	fn take_sd_publisher(&mut self) -> Vec<SdPublisherProperty> {
1034		std::mem::take(&mut self.r#sd_publisher)
1035	}
1036	fn get_size(&self) -> &[SizeProperty] {
1037		self.r#size.as_slice()
1038	}
1039	fn take_size(&mut self) -> Vec<SizeProperty> {
1040		std::mem::take(&mut self.r#size)
1041	}
1042	fn get_source_organization(&self) -> &[SourceOrganizationProperty] {
1043		self.r#source_organization.as_slice()
1044	}
1045	fn take_source_organization(&mut self) -> Vec<SourceOrganizationProperty> {
1046		std::mem::take(&mut self.r#source_organization)
1047	}
1048	fn get_spatial(&self) -> &[SpatialProperty] {
1049		self.r#spatial.as_slice()
1050	}
1051	fn take_spatial(&mut self) -> Vec<SpatialProperty> {
1052		std::mem::take(&mut self.r#spatial)
1053	}
1054	fn get_spatial_coverage(&self) -> &[SpatialCoverageProperty] {
1055		self.r#spatial_coverage.as_slice()
1056	}
1057	fn take_spatial_coverage(&mut self) -> Vec<SpatialCoverageProperty> {
1058		std::mem::take(&mut self.r#spatial_coverage)
1059	}
1060	fn get_sponsor(&self) -> &[SponsorProperty] {
1061		self.r#sponsor.as_slice()
1062	}
1063	fn take_sponsor(&mut self) -> Vec<SponsorProperty> {
1064		std::mem::take(&mut self.r#sponsor)
1065	}
1066	fn get_teaches(&self) -> &[TeachesProperty] {
1067		self.r#teaches.as_slice()
1068	}
1069	fn take_teaches(&mut self) -> Vec<TeachesProperty> {
1070		std::mem::take(&mut self.r#teaches)
1071	}
1072	fn get_temporal(&self) -> &[TemporalProperty] {
1073		self.r#temporal.as_slice()
1074	}
1075	fn take_temporal(&mut self) -> Vec<TemporalProperty> {
1076		std::mem::take(&mut self.r#temporal)
1077	}
1078	fn get_temporal_coverage(&self) -> &[TemporalCoverageProperty] {
1079		self.r#temporal_coverage.as_slice()
1080	}
1081	fn take_temporal_coverage(&mut self) -> Vec<TemporalCoverageProperty> {
1082		std::mem::take(&mut self.r#temporal_coverage)
1083	}
1084	fn get_text(&self) -> &[TextProperty] {
1085		self.r#text.as_slice()
1086	}
1087	fn take_text(&mut self) -> Vec<TextProperty> {
1088		std::mem::take(&mut self.r#text)
1089	}
1090	fn get_thumbnail(&self) -> &[ThumbnailProperty] {
1091		self.r#thumbnail.as_slice()
1092	}
1093	fn take_thumbnail(&mut self) -> Vec<ThumbnailProperty> {
1094		std::mem::take(&mut self.r#thumbnail)
1095	}
1096	fn get_thumbnail_url(&self) -> &[ThumbnailUrlProperty] {
1097		self.r#thumbnail_url.as_slice()
1098	}
1099	fn take_thumbnail_url(&mut self) -> Vec<ThumbnailUrlProperty> {
1100		std::mem::take(&mut self.r#thumbnail_url)
1101	}
1102	fn get_time_required(&self) -> &[TimeRequiredProperty] {
1103		self.r#time_required.as_slice()
1104	}
1105	fn take_time_required(&mut self) -> Vec<TimeRequiredProperty> {
1106		std::mem::take(&mut self.r#time_required)
1107	}
1108	fn get_translation_of_work(&self) -> &[TranslationOfWorkProperty] {
1109		self.r#translation_of_work.as_slice()
1110	}
1111	fn take_translation_of_work(&mut self) -> Vec<TranslationOfWorkProperty> {
1112		std::mem::take(&mut self.r#translation_of_work)
1113	}
1114	fn get_translator(&self) -> &[TranslatorProperty] {
1115		self.r#translator.as_slice()
1116	}
1117	fn take_translator(&mut self) -> Vec<TranslatorProperty> {
1118		std::mem::take(&mut self.r#translator)
1119	}
1120	fn get_typical_age_range(&self) -> &[TypicalAgeRangeProperty] {
1121		self.r#typical_age_range.as_slice()
1122	}
1123	fn take_typical_age_range(&mut self) -> Vec<TypicalAgeRangeProperty> {
1124		std::mem::take(&mut self.r#typical_age_range)
1125	}
1126	fn get_usage_info(&self) -> &[UsageInfoProperty] {
1127		self.r#usage_info.as_slice()
1128	}
1129	fn take_usage_info(&mut self) -> Vec<UsageInfoProperty> {
1130		std::mem::take(&mut self.r#usage_info)
1131	}
1132	fn get_version(&self) -> &[VersionProperty] {
1133		self.r#version.as_slice()
1134	}
1135	fn take_version(&mut self) -> Vec<VersionProperty> {
1136		std::mem::take(&mut self.r#version)
1137	}
1138	fn get_video(&self) -> &[VideoProperty] {
1139		self.r#video.as_slice()
1140	}
1141	fn take_video(&mut self) -> Vec<VideoProperty> {
1142		std::mem::take(&mut self.r#video)
1143	}
1144	fn get_work_example(&self) -> &[WorkExampleProperty] {
1145		self.r#work_example.as_slice()
1146	}
1147	fn take_work_example(&mut self) -> Vec<WorkExampleProperty> {
1148		std::mem::take(&mut self.r#work_example)
1149	}
1150	fn get_work_translation(&self) -> &[WorkTranslationProperty] {
1151		self.r#work_translation.as_slice()
1152	}
1153	fn take_work_translation(&mut self) -> Vec<WorkTranslationProperty> {
1154		std::mem::take(&mut self.r#work_translation)
1155	}
1156}
1157impl GameTrait for VideoGame {
1158	fn get_character_attribute(&self) -> &[CharacterAttributeProperty] {
1159		self.r#character_attribute.as_slice()
1160	}
1161	fn take_character_attribute(&mut self) -> Vec<CharacterAttributeProperty> {
1162		std::mem::take(&mut self.r#character_attribute)
1163	}
1164	fn get_game_item(&self) -> &[GameItemProperty] {
1165		self.r#game_item.as_slice()
1166	}
1167	fn take_game_item(&mut self) -> Vec<GameItemProperty> {
1168		std::mem::take(&mut self.r#game_item)
1169	}
1170	fn get_game_location(&self) -> &[GameLocationProperty] {
1171		self.r#game_location.as_slice()
1172	}
1173	fn take_game_location(&mut self) -> Vec<GameLocationProperty> {
1174		std::mem::take(&mut self.r#game_location)
1175	}
1176	fn get_number_of_players(&self) -> &[NumberOfPlayersProperty] {
1177		self.r#number_of_players.as_slice()
1178	}
1179	fn take_number_of_players(&mut self) -> Vec<NumberOfPlayersProperty> {
1180		std::mem::take(&mut self.r#number_of_players)
1181	}
1182	fn get_quest(&self) -> &[QuestProperty] {
1183		self.r#quest.as_slice()
1184	}
1185	fn take_quest(&mut self) -> Vec<QuestProperty> {
1186		std::mem::take(&mut self.r#quest)
1187	}
1188}
1189impl SoftwareApplicationTrait for VideoGame {
1190	fn get_application_category(&self) -> &[ApplicationCategoryProperty] {
1191		self.r#application_category.as_slice()
1192	}
1193	fn take_application_category(&mut self) -> Vec<ApplicationCategoryProperty> {
1194		std::mem::take(&mut self.r#application_category)
1195	}
1196	fn get_application_sub_category(&self) -> &[ApplicationSubCategoryProperty] {
1197		self.r#application_sub_category.as_slice()
1198	}
1199	fn take_application_sub_category(&mut self) -> Vec<ApplicationSubCategoryProperty> {
1200		std::mem::take(&mut self.r#application_sub_category)
1201	}
1202	fn get_application_suite(&self) -> &[ApplicationSuiteProperty] {
1203		self.r#application_suite.as_slice()
1204	}
1205	fn take_application_suite(&mut self) -> Vec<ApplicationSuiteProperty> {
1206		std::mem::take(&mut self.r#application_suite)
1207	}
1208	fn get_available_on_device(&self) -> &[AvailableOnDeviceProperty] {
1209		self.r#available_on_device.as_slice()
1210	}
1211	fn take_available_on_device(&mut self) -> Vec<AvailableOnDeviceProperty> {
1212		std::mem::take(&mut self.r#available_on_device)
1213	}
1214	fn get_countries_not_supported(&self) -> &[CountriesNotSupportedProperty] {
1215		self.r#countries_not_supported.as_slice()
1216	}
1217	fn take_countries_not_supported(&mut self) -> Vec<CountriesNotSupportedProperty> {
1218		std::mem::take(&mut self.r#countries_not_supported)
1219	}
1220	fn get_countries_supported(&self) -> &[CountriesSupportedProperty] {
1221		self.r#countries_supported.as_slice()
1222	}
1223	fn take_countries_supported(&mut self) -> Vec<CountriesSupportedProperty> {
1224		std::mem::take(&mut self.r#countries_supported)
1225	}
1226	fn get_device(&self) -> &[DeviceProperty] {
1227		self.r#device.as_slice()
1228	}
1229	fn take_device(&mut self) -> Vec<DeviceProperty> {
1230		std::mem::take(&mut self.r#device)
1231	}
1232	fn get_download_url(&self) -> &[DownloadUrlProperty] {
1233		self.r#download_url.as_slice()
1234	}
1235	fn take_download_url(&mut self) -> Vec<DownloadUrlProperty> {
1236		std::mem::take(&mut self.r#download_url)
1237	}
1238	fn get_feature_list(&self) -> &[FeatureListProperty] {
1239		self.r#feature_list.as_slice()
1240	}
1241	fn take_feature_list(&mut self) -> Vec<FeatureListProperty> {
1242		std::mem::take(&mut self.r#feature_list)
1243	}
1244	fn get_file_size(&self) -> &[FileSizeProperty] {
1245		self.r#file_size.as_slice()
1246	}
1247	fn take_file_size(&mut self) -> Vec<FileSizeProperty> {
1248		std::mem::take(&mut self.r#file_size)
1249	}
1250	fn get_install_url(&self) -> &[InstallUrlProperty] {
1251		self.r#install_url.as_slice()
1252	}
1253	fn take_install_url(&mut self) -> Vec<InstallUrlProperty> {
1254		std::mem::take(&mut self.r#install_url)
1255	}
1256	fn get_memory_requirements(&self) -> &[MemoryRequirementsProperty] {
1257		self.r#memory_requirements.as_slice()
1258	}
1259	fn take_memory_requirements(&mut self) -> Vec<MemoryRequirementsProperty> {
1260		std::mem::take(&mut self.r#memory_requirements)
1261	}
1262	fn get_operating_system(&self) -> &[OperatingSystemProperty] {
1263		self.r#operating_system.as_slice()
1264	}
1265	fn take_operating_system(&mut self) -> Vec<OperatingSystemProperty> {
1266		std::mem::take(&mut self.r#operating_system)
1267	}
1268	fn get_permissions(&self) -> &[PermissionsProperty] {
1269		self.r#permissions.as_slice()
1270	}
1271	fn take_permissions(&mut self) -> Vec<PermissionsProperty> {
1272		std::mem::take(&mut self.r#permissions)
1273	}
1274	fn get_processor_requirements(&self) -> &[ProcessorRequirementsProperty] {
1275		self.r#processor_requirements.as_slice()
1276	}
1277	fn take_processor_requirements(&mut self) -> Vec<ProcessorRequirementsProperty> {
1278		std::mem::take(&mut self.r#processor_requirements)
1279	}
1280	fn get_release_notes(&self) -> &[ReleaseNotesProperty] {
1281		self.r#release_notes.as_slice()
1282	}
1283	fn take_release_notes(&mut self) -> Vec<ReleaseNotesProperty> {
1284		std::mem::take(&mut self.r#release_notes)
1285	}
1286	fn get_requirements(&self) -> &[RequirementsProperty] {
1287		self.r#requirements.as_slice()
1288	}
1289	fn take_requirements(&mut self) -> Vec<RequirementsProperty> {
1290		std::mem::take(&mut self.r#requirements)
1291	}
1292	fn get_screenshot(&self) -> &[ScreenshotProperty] {
1293		self.r#screenshot.as_slice()
1294	}
1295	fn take_screenshot(&mut self) -> Vec<ScreenshotProperty> {
1296		std::mem::take(&mut self.r#screenshot)
1297	}
1298	fn get_software_add_on(&self) -> &[SoftwareAddOnProperty] {
1299		self.r#software_add_on.as_slice()
1300	}
1301	fn take_software_add_on(&mut self) -> Vec<SoftwareAddOnProperty> {
1302		std::mem::take(&mut self.r#software_add_on)
1303	}
1304	fn get_software_help(&self) -> &[SoftwareHelpProperty] {
1305		self.r#software_help.as_slice()
1306	}
1307	fn take_software_help(&mut self) -> Vec<SoftwareHelpProperty> {
1308		std::mem::take(&mut self.r#software_help)
1309	}
1310	fn get_software_requirements(&self) -> &[SoftwareRequirementsProperty] {
1311		self.r#software_requirements.as_slice()
1312	}
1313	fn take_software_requirements(&mut self) -> Vec<SoftwareRequirementsProperty> {
1314		std::mem::take(&mut self.r#software_requirements)
1315	}
1316	fn get_software_version(&self) -> &[SoftwareVersionProperty] {
1317		self.r#software_version.as_slice()
1318	}
1319	fn take_software_version(&mut self) -> Vec<SoftwareVersionProperty> {
1320		std::mem::take(&mut self.r#software_version)
1321	}
1322	fn get_storage_requirements(&self) -> &[StorageRequirementsProperty] {
1323		self.r#storage_requirements.as_slice()
1324	}
1325	fn take_storage_requirements(&mut self) -> Vec<StorageRequirementsProperty> {
1326		std::mem::take(&mut self.r#storage_requirements)
1327	}
1328	fn get_supporting_data(&self) -> &[SupportingDataProperty] {
1329		self.r#supporting_data.as_slice()
1330	}
1331	fn take_supporting_data(&mut self) -> Vec<SupportingDataProperty> {
1332		std::mem::take(&mut self.r#supporting_data)
1333	}
1334}
1335impl ThingTrait for VideoGame {
1336	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
1337		self.r#additional_type.as_slice()
1338	}
1339	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
1340		std::mem::take(&mut self.r#additional_type)
1341	}
1342	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
1343		self.r#alternate_name.as_slice()
1344	}
1345	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
1346		std::mem::take(&mut self.r#alternate_name)
1347	}
1348	fn get_description(&self) -> &[DescriptionProperty] {
1349		self.r#description.as_slice()
1350	}
1351	fn take_description(&mut self) -> Vec<DescriptionProperty> {
1352		std::mem::take(&mut self.r#description)
1353	}
1354	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
1355		self.r#disambiguating_description.as_slice()
1356	}
1357	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
1358		std::mem::take(&mut self.r#disambiguating_description)
1359	}
1360	fn get_identifier(&self) -> &[IdentifierProperty] {
1361		self.r#identifier.as_slice()
1362	}
1363	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
1364		std::mem::take(&mut self.r#identifier)
1365	}
1366	fn get_image(&self) -> &[ImageProperty] {
1367		self.r#image.as_slice()
1368	}
1369	fn take_image(&mut self) -> Vec<ImageProperty> {
1370		std::mem::take(&mut self.r#image)
1371	}
1372	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
1373		self.r#main_entity_of_page.as_slice()
1374	}
1375	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
1376		std::mem::take(&mut self.r#main_entity_of_page)
1377	}
1378	fn get_name(&self) -> &[NameProperty] {
1379		self.r#name.as_slice()
1380	}
1381	fn take_name(&mut self) -> Vec<NameProperty> {
1382		std::mem::take(&mut self.r#name)
1383	}
1384	fn get_potential_action(&self) -> &[PotentialActionProperty] {
1385		self.r#potential_action.as_slice()
1386	}
1387	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
1388		std::mem::take(&mut self.r#potential_action)
1389	}
1390	fn get_same_as(&self) -> &[SameAsProperty] {
1391		self.r#same_as.as_slice()
1392	}
1393	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
1394		std::mem::take(&mut self.r#same_as)
1395	}
1396	fn get_subject_of(&self) -> &[SubjectOfProperty] {
1397		self.r#subject_of.as_slice()
1398	}
1399	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
1400		std::mem::take(&mut self.r#subject_of)
1401	}
1402	fn get_url(&self) -> &[UrlProperty] {
1403		self.r#url.as_slice()
1404	}
1405	fn take_url(&mut self) -> Vec<UrlProperty> {
1406		std::mem::take(&mut self.r#url)
1407	}
1408}
1409#[cfg(feature = "serde")]
1410mod serde {
1411	use std::{fmt, fmt::Formatter};
1412
1413	use ::serde::{
1414		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
1415	};
1416
1417	use super::*;
1418	impl Serialize for VideoGame {
1419		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1420		where
1421			S: Serializer,
1422		{
1423			let len: usize = [
1424				!Vec::is_empty(&self.r#actor) as usize,
1425				!Vec::is_empty(&self.r#actors) as usize,
1426				!Vec::is_empty(&self.r#cheat_code) as usize,
1427				!Vec::is_empty(&self.r#director) as usize,
1428				!Vec::is_empty(&self.r#directors) as usize,
1429				!Vec::is_empty(&self.r#game_edition) as usize,
1430				!Vec::is_empty(&self.r#game_platform) as usize,
1431				!Vec::is_empty(&self.r#game_server) as usize,
1432				!Vec::is_empty(&self.r#game_tip) as usize,
1433				!Vec::is_empty(&self.r#music_by) as usize,
1434				!Vec::is_empty(&self.r#play_mode) as usize,
1435				!Vec::is_empty(&self.r#trailer) as usize,
1436				!Vec::is_empty(&self.r#about) as usize,
1437				!Vec::is_empty(&self.r#abstract) as usize,
1438				!Vec::is_empty(&self.r#access_mode) as usize,
1439				!Vec::is_empty(&self.r#access_mode_sufficient) as usize,
1440				!Vec::is_empty(&self.r#accessibility_api) as usize,
1441				!Vec::is_empty(&self.r#accessibility_control) as usize,
1442				!Vec::is_empty(&self.r#accessibility_feature) as usize,
1443				!Vec::is_empty(&self.r#accessibility_hazard) as usize,
1444				!Vec::is_empty(&self.r#accessibility_summary) as usize,
1445				!Vec::is_empty(&self.r#accountable_person) as usize,
1446				!Vec::is_empty(&self.r#acquire_license_page) as usize,
1447				!Vec::is_empty(&self.r#aggregate_rating) as usize,
1448				!Vec::is_empty(&self.r#alternative_headline) as usize,
1449				!Vec::is_empty(&self.r#archived_at) as usize,
1450				!Vec::is_empty(&self.r#assesses) as usize,
1451				!Vec::is_empty(&self.r#associated_media) as usize,
1452				!Vec::is_empty(&self.r#audience) as usize,
1453				!Vec::is_empty(&self.r#audio) as usize,
1454				!Vec::is_empty(&self.r#author) as usize,
1455				!Vec::is_empty(&self.r#award) as usize,
1456				!Vec::is_empty(&self.r#awards) as usize,
1457				!Vec::is_empty(&self.r#character) as usize,
1458				!Vec::is_empty(&self.r#citation) as usize,
1459				!Vec::is_empty(&self.r#comment) as usize,
1460				!Vec::is_empty(&self.r#comment_count) as usize,
1461				!Vec::is_empty(&self.r#conditions_of_access) as usize,
1462				!Vec::is_empty(&self.r#content_location) as usize,
1463				!Vec::is_empty(&self.r#content_rating) as usize,
1464				!Vec::is_empty(&self.r#content_reference_time) as usize,
1465				!Vec::is_empty(&self.r#contributor) as usize,
1466				!Vec::is_empty(&self.r#copyright_holder) as usize,
1467				!Vec::is_empty(&self.r#copyright_notice) as usize,
1468				!Vec::is_empty(&self.r#copyright_year) as usize,
1469				!Vec::is_empty(&self.r#correction) as usize,
1470				!Vec::is_empty(&self.r#country_of_origin) as usize,
1471				!Vec::is_empty(&self.r#creative_work_status) as usize,
1472				!Vec::is_empty(&self.r#creator) as usize,
1473				!Vec::is_empty(&self.r#credit_text) as usize,
1474				!Vec::is_empty(&self.r#date_created) as usize,
1475				!Vec::is_empty(&self.r#date_modified) as usize,
1476				!Vec::is_empty(&self.r#date_published) as usize,
1477				!Vec::is_empty(&self.r#discussion_url) as usize,
1478				!Vec::is_empty(&self.r#edit_eidr) as usize,
1479				!Vec::is_empty(&self.r#editor) as usize,
1480				!Vec::is_empty(&self.r#educational_alignment) as usize,
1481				!Vec::is_empty(&self.r#educational_level) as usize,
1482				!Vec::is_empty(&self.r#educational_use) as usize,
1483				!Vec::is_empty(&self.r#encoding) as usize,
1484				!Vec::is_empty(&self.r#encoding_format) as usize,
1485				!Vec::is_empty(&self.r#encodings) as usize,
1486				!Vec::is_empty(&self.r#example_of_work) as usize,
1487				!Vec::is_empty(&self.r#expires) as usize,
1488				!Vec::is_empty(&self.r#file_format) as usize,
1489				!Vec::is_empty(&self.r#funder) as usize,
1490				!Vec::is_empty(&self.r#funding) as usize,
1491				!Vec::is_empty(&self.r#genre) as usize,
1492				!Vec::is_empty(&self.r#has_part) as usize,
1493				!Vec::is_empty(&self.r#headline) as usize,
1494				!Vec::is_empty(&self.r#in_language) as usize,
1495				!Vec::is_empty(&self.r#interaction_statistic) as usize,
1496				!Vec::is_empty(&self.r#interactivity_type) as usize,
1497				!Vec::is_empty(&self.r#interpreted_as_claim) as usize,
1498				!Vec::is_empty(&self.r#is_accessible_for_free) as usize,
1499				!Vec::is_empty(&self.r#is_based_on) as usize,
1500				!Vec::is_empty(&self.r#is_based_on_url) as usize,
1501				!Vec::is_empty(&self.r#is_family_friendly) as usize,
1502				!Vec::is_empty(&self.r#is_part_of) as usize,
1503				!Vec::is_empty(&self.r#keywords) as usize,
1504				!Vec::is_empty(&self.r#learning_resource_type) as usize,
1505				!Vec::is_empty(&self.r#license) as usize,
1506				!Vec::is_empty(&self.r#location_created) as usize,
1507				!Vec::is_empty(&self.r#main_entity) as usize,
1508				!Vec::is_empty(&self.r#maintainer) as usize,
1509				!Vec::is_empty(&self.r#material) as usize,
1510				!Vec::is_empty(&self.r#material_extent) as usize,
1511				!Vec::is_empty(&self.r#mentions) as usize,
1512				!Vec::is_empty(&self.r#offers) as usize,
1513				!Vec::is_empty(&self.r#pattern) as usize,
1514				!Vec::is_empty(&self.r#position) as usize,
1515				!Vec::is_empty(&self.r#producer) as usize,
1516				!Vec::is_empty(&self.r#provider) as usize,
1517				!Vec::is_empty(&self.r#publication) as usize,
1518				!Vec::is_empty(&self.r#publisher) as usize,
1519				!Vec::is_empty(&self.r#publisher_imprint) as usize,
1520				!Vec::is_empty(&self.r#publishing_principles) as usize,
1521				!Vec::is_empty(&self.r#recorded_at) as usize,
1522				!Vec::is_empty(&self.r#released_event) as usize,
1523				!Vec::is_empty(&self.r#review) as usize,
1524				!Vec::is_empty(&self.r#reviews) as usize,
1525				!Vec::is_empty(&self.r#schema_version) as usize,
1526				!Vec::is_empty(&self.r#sd_date_published) as usize,
1527				!Vec::is_empty(&self.r#sd_license) as usize,
1528				!Vec::is_empty(&self.r#sd_publisher) as usize,
1529				!Vec::is_empty(&self.r#size) as usize,
1530				!Vec::is_empty(&self.r#source_organization) as usize,
1531				!Vec::is_empty(&self.r#spatial) as usize,
1532				!Vec::is_empty(&self.r#spatial_coverage) as usize,
1533				!Vec::is_empty(&self.r#sponsor) as usize,
1534				!Vec::is_empty(&self.r#teaches) as usize,
1535				!Vec::is_empty(&self.r#temporal) as usize,
1536				!Vec::is_empty(&self.r#temporal_coverage) as usize,
1537				!Vec::is_empty(&self.r#text) as usize,
1538				!Vec::is_empty(&self.r#thumbnail) as usize,
1539				!Vec::is_empty(&self.r#thumbnail_url) as usize,
1540				!Vec::is_empty(&self.r#time_required) as usize,
1541				!Vec::is_empty(&self.r#translation_of_work) as usize,
1542				!Vec::is_empty(&self.r#translator) as usize,
1543				!Vec::is_empty(&self.r#typical_age_range) as usize,
1544				!Vec::is_empty(&self.r#usage_info) as usize,
1545				!Vec::is_empty(&self.r#version) as usize,
1546				!Vec::is_empty(&self.r#video) as usize,
1547				!Vec::is_empty(&self.r#work_example) as usize,
1548				!Vec::is_empty(&self.r#work_translation) as usize,
1549				!Vec::is_empty(&self.r#character_attribute) as usize,
1550				!Vec::is_empty(&self.r#game_item) as usize,
1551				!Vec::is_empty(&self.r#game_location) as usize,
1552				!Vec::is_empty(&self.r#number_of_players) as usize,
1553				!Vec::is_empty(&self.r#quest) as usize,
1554				!Vec::is_empty(&self.r#application_category) as usize,
1555				!Vec::is_empty(&self.r#application_sub_category) as usize,
1556				!Vec::is_empty(&self.r#application_suite) as usize,
1557				!Vec::is_empty(&self.r#available_on_device) as usize,
1558				!Vec::is_empty(&self.r#countries_not_supported) as usize,
1559				!Vec::is_empty(&self.r#countries_supported) as usize,
1560				!Vec::is_empty(&self.r#device) as usize,
1561				!Vec::is_empty(&self.r#download_url) as usize,
1562				!Vec::is_empty(&self.r#feature_list) as usize,
1563				!Vec::is_empty(&self.r#file_size) as usize,
1564				!Vec::is_empty(&self.r#install_url) as usize,
1565				!Vec::is_empty(&self.r#memory_requirements) as usize,
1566				!Vec::is_empty(&self.r#operating_system) as usize,
1567				!Vec::is_empty(&self.r#permissions) as usize,
1568				!Vec::is_empty(&self.r#processor_requirements) as usize,
1569				!Vec::is_empty(&self.r#release_notes) as usize,
1570				!Vec::is_empty(&self.r#requirements) as usize,
1571				!Vec::is_empty(&self.r#screenshot) as usize,
1572				!Vec::is_empty(&self.r#software_add_on) as usize,
1573				!Vec::is_empty(&self.r#software_help) as usize,
1574				!Vec::is_empty(&self.r#software_requirements) as usize,
1575				!Vec::is_empty(&self.r#software_version) as usize,
1576				!Vec::is_empty(&self.r#storage_requirements) as usize,
1577				!Vec::is_empty(&self.r#supporting_data) as usize,
1578				!Vec::is_empty(&self.r#additional_type) as usize,
1579				!Vec::is_empty(&self.r#alternate_name) as usize,
1580				!Vec::is_empty(&self.r#description) as usize,
1581				!Vec::is_empty(&self.r#disambiguating_description) as usize,
1582				!Vec::is_empty(&self.r#identifier) as usize,
1583				!Vec::is_empty(&self.r#image) as usize,
1584				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
1585				!Vec::is_empty(&self.r#name) as usize,
1586				!Vec::is_empty(&self.r#potential_action) as usize,
1587				!Vec::is_empty(&self.r#same_as) as usize,
1588				!Vec::is_empty(&self.r#subject_of) as usize,
1589				!Vec::is_empty(&self.r#url) as usize,
1590			]
1591			.iter()
1592			.sum();
1593			let mut serialize_struct = Serializer::serialize_struct(serializer, "VideoGame", len)?;
1594			if !Vec::is_empty(&self.r#actor) {
1595				serialize_struct.serialize_field("actor", {
1596					struct SerializeWith<'a>(&'a Vec<ActorProperty>);
1597					impl<'a> Serialize for SerializeWith<'a> {
1598						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1599						where
1600							S: Serializer,
1601						{
1602							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1603								self.0, serializer,
1604							)
1605						}
1606					}
1607					&SerializeWith(&self.r#actor)
1608				})?;
1609			} else {
1610				serialize_struct.skip_field("actor")?;
1611			}
1612			if !Vec::is_empty(&self.r#actors) {
1613				serialize_struct.serialize_field("actors", {
1614					struct SerializeWith<'a>(&'a Vec<ActorsProperty>);
1615					impl<'a> Serialize for SerializeWith<'a> {
1616						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1617						where
1618							S: Serializer,
1619						{
1620							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1621								self.0, serializer,
1622							)
1623						}
1624					}
1625					&SerializeWith(&self.r#actors)
1626				})?;
1627			} else {
1628				serialize_struct.skip_field("actors")?;
1629			}
1630			if !Vec::is_empty(&self.r#cheat_code) {
1631				serialize_struct.serialize_field("cheatCode", {
1632					struct SerializeWith<'a>(&'a Vec<CheatCodeProperty>);
1633					impl<'a> Serialize for SerializeWith<'a> {
1634						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1635						where
1636							S: Serializer,
1637						{
1638							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1639								self.0, serializer,
1640							)
1641						}
1642					}
1643					&SerializeWith(&self.r#cheat_code)
1644				})?;
1645			} else {
1646				serialize_struct.skip_field("cheatCode")?;
1647			}
1648			if !Vec::is_empty(&self.r#director) {
1649				serialize_struct.serialize_field("director", {
1650					struct SerializeWith<'a>(&'a Vec<DirectorProperty>);
1651					impl<'a> Serialize for SerializeWith<'a> {
1652						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1653						where
1654							S: Serializer,
1655						{
1656							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1657								self.0, serializer,
1658							)
1659						}
1660					}
1661					&SerializeWith(&self.r#director)
1662				})?;
1663			} else {
1664				serialize_struct.skip_field("director")?;
1665			}
1666			if !Vec::is_empty(&self.r#directors) {
1667				serialize_struct.serialize_field("directors", {
1668					struct SerializeWith<'a>(&'a Vec<DirectorsProperty>);
1669					impl<'a> Serialize for SerializeWith<'a> {
1670						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1671						where
1672							S: Serializer,
1673						{
1674							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1675								self.0, serializer,
1676							)
1677						}
1678					}
1679					&SerializeWith(&self.r#directors)
1680				})?;
1681			} else {
1682				serialize_struct.skip_field("directors")?;
1683			}
1684			if !Vec::is_empty(&self.r#game_edition) {
1685				serialize_struct.serialize_field("gameEdition", {
1686					struct SerializeWith<'a>(&'a Vec<GameEditionProperty>);
1687					impl<'a> Serialize for SerializeWith<'a> {
1688						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1689						where
1690							S: Serializer,
1691						{
1692							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1693								self.0, serializer,
1694							)
1695						}
1696					}
1697					&SerializeWith(&self.r#game_edition)
1698				})?;
1699			} else {
1700				serialize_struct.skip_field("gameEdition")?;
1701			}
1702			if !Vec::is_empty(&self.r#game_platform) {
1703				serialize_struct.serialize_field("gamePlatform", {
1704					struct SerializeWith<'a>(&'a Vec<GamePlatformProperty>);
1705					impl<'a> Serialize for SerializeWith<'a> {
1706						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1707						where
1708							S: Serializer,
1709						{
1710							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1711								self.0, serializer,
1712							)
1713						}
1714					}
1715					&SerializeWith(&self.r#game_platform)
1716				})?;
1717			} else {
1718				serialize_struct.skip_field("gamePlatform")?;
1719			}
1720			if !Vec::is_empty(&self.r#game_server) {
1721				serialize_struct.serialize_field("gameServer", {
1722					struct SerializeWith<'a>(&'a Vec<GameServerProperty>);
1723					impl<'a> Serialize for SerializeWith<'a> {
1724						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1725						where
1726							S: Serializer,
1727						{
1728							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1729								self.0, serializer,
1730							)
1731						}
1732					}
1733					&SerializeWith(&self.r#game_server)
1734				})?;
1735			} else {
1736				serialize_struct.skip_field("gameServer")?;
1737			}
1738			if !Vec::is_empty(&self.r#game_tip) {
1739				serialize_struct.serialize_field("gameTip", {
1740					struct SerializeWith<'a>(&'a Vec<GameTipProperty>);
1741					impl<'a> Serialize for SerializeWith<'a> {
1742						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1743						where
1744							S: Serializer,
1745						{
1746							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1747								self.0, serializer,
1748							)
1749						}
1750					}
1751					&SerializeWith(&self.r#game_tip)
1752				})?;
1753			} else {
1754				serialize_struct.skip_field("gameTip")?;
1755			}
1756			if !Vec::is_empty(&self.r#music_by) {
1757				serialize_struct.serialize_field("musicBy", {
1758					struct SerializeWith<'a>(&'a Vec<MusicByProperty>);
1759					impl<'a> Serialize for SerializeWith<'a> {
1760						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1761						where
1762							S: Serializer,
1763						{
1764							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1765								self.0, serializer,
1766							)
1767						}
1768					}
1769					&SerializeWith(&self.r#music_by)
1770				})?;
1771			} else {
1772				serialize_struct.skip_field("musicBy")?;
1773			}
1774			if !Vec::is_empty(&self.r#play_mode) {
1775				serialize_struct.serialize_field("playMode", {
1776					struct SerializeWith<'a>(&'a Vec<PlayModeProperty>);
1777					impl<'a> Serialize for SerializeWith<'a> {
1778						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1779						where
1780							S: Serializer,
1781						{
1782							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1783								self.0, serializer,
1784							)
1785						}
1786					}
1787					&SerializeWith(&self.r#play_mode)
1788				})?;
1789			} else {
1790				serialize_struct.skip_field("playMode")?;
1791			}
1792			if !Vec::is_empty(&self.r#trailer) {
1793				serialize_struct.serialize_field("trailer", {
1794					struct SerializeWith<'a>(&'a Vec<TrailerProperty>);
1795					impl<'a> Serialize for SerializeWith<'a> {
1796						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1797						where
1798							S: Serializer,
1799						{
1800							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1801								self.0, serializer,
1802							)
1803						}
1804					}
1805					&SerializeWith(&self.r#trailer)
1806				})?;
1807			} else {
1808				serialize_struct.skip_field("trailer")?;
1809			}
1810			if !Vec::is_empty(&self.r#about) {
1811				serialize_struct.serialize_field("about", {
1812					struct SerializeWith<'a>(&'a Vec<AboutProperty>);
1813					impl<'a> Serialize for SerializeWith<'a> {
1814						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1815						where
1816							S: Serializer,
1817						{
1818							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1819								self.0, serializer,
1820							)
1821						}
1822					}
1823					&SerializeWith(&self.r#about)
1824				})?;
1825			} else {
1826				serialize_struct.skip_field("about")?;
1827			}
1828			if !Vec::is_empty(&self.r#abstract) {
1829				serialize_struct.serialize_field("abstract", {
1830					struct SerializeWith<'a>(&'a Vec<AbstractProperty>);
1831					impl<'a> Serialize for SerializeWith<'a> {
1832						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1833						where
1834							S: Serializer,
1835						{
1836							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1837								self.0, serializer,
1838							)
1839						}
1840					}
1841					&SerializeWith(&self.r#abstract)
1842				})?;
1843			} else {
1844				serialize_struct.skip_field("abstract")?;
1845			}
1846			if !Vec::is_empty(&self.r#access_mode) {
1847				serialize_struct.serialize_field("accessMode", {
1848					struct SerializeWith<'a>(&'a Vec<AccessModeProperty>);
1849					impl<'a> Serialize for SerializeWith<'a> {
1850						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1851						where
1852							S: Serializer,
1853						{
1854							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1855								self.0, serializer,
1856							)
1857						}
1858					}
1859					&SerializeWith(&self.r#access_mode)
1860				})?;
1861			} else {
1862				serialize_struct.skip_field("accessMode")?;
1863			}
1864			if !Vec::is_empty(&self.r#access_mode_sufficient) {
1865				serialize_struct.serialize_field("accessModeSufficient", {
1866					struct SerializeWith<'a>(&'a Vec<AccessModeSufficientProperty>);
1867					impl<'a> Serialize for SerializeWith<'a> {
1868						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1869						where
1870							S: Serializer,
1871						{
1872							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1873								self.0, serializer,
1874							)
1875						}
1876					}
1877					&SerializeWith(&self.r#access_mode_sufficient)
1878				})?;
1879			} else {
1880				serialize_struct.skip_field("accessModeSufficient")?;
1881			}
1882			if !Vec::is_empty(&self.r#accessibility_api) {
1883				serialize_struct.serialize_field("accessibilityAPI", {
1884					struct SerializeWith<'a>(&'a Vec<AccessibilityApiProperty>);
1885					impl<'a> Serialize for SerializeWith<'a> {
1886						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1887						where
1888							S: Serializer,
1889						{
1890							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1891								self.0, serializer,
1892							)
1893						}
1894					}
1895					&SerializeWith(&self.r#accessibility_api)
1896				})?;
1897			} else {
1898				serialize_struct.skip_field("accessibilityAPI")?;
1899			}
1900			if !Vec::is_empty(&self.r#accessibility_control) {
1901				serialize_struct.serialize_field("accessibilityControl", {
1902					struct SerializeWith<'a>(&'a Vec<AccessibilityControlProperty>);
1903					impl<'a> Serialize for SerializeWith<'a> {
1904						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1905						where
1906							S: Serializer,
1907						{
1908							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1909								self.0, serializer,
1910							)
1911						}
1912					}
1913					&SerializeWith(&self.r#accessibility_control)
1914				})?;
1915			} else {
1916				serialize_struct.skip_field("accessibilityControl")?;
1917			}
1918			if !Vec::is_empty(&self.r#accessibility_feature) {
1919				serialize_struct.serialize_field("accessibilityFeature", {
1920					struct SerializeWith<'a>(&'a Vec<AccessibilityFeatureProperty>);
1921					impl<'a> Serialize for SerializeWith<'a> {
1922						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1923						where
1924							S: Serializer,
1925						{
1926							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1927								self.0, serializer,
1928							)
1929						}
1930					}
1931					&SerializeWith(&self.r#accessibility_feature)
1932				})?;
1933			} else {
1934				serialize_struct.skip_field("accessibilityFeature")?;
1935			}
1936			if !Vec::is_empty(&self.r#accessibility_hazard) {
1937				serialize_struct.serialize_field("accessibilityHazard", {
1938					struct SerializeWith<'a>(&'a Vec<AccessibilityHazardProperty>);
1939					impl<'a> Serialize for SerializeWith<'a> {
1940						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1941						where
1942							S: Serializer,
1943						{
1944							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1945								self.0, serializer,
1946							)
1947						}
1948					}
1949					&SerializeWith(&self.r#accessibility_hazard)
1950				})?;
1951			} else {
1952				serialize_struct.skip_field("accessibilityHazard")?;
1953			}
1954			if !Vec::is_empty(&self.r#accessibility_summary) {
1955				serialize_struct.serialize_field("accessibilitySummary", {
1956					struct SerializeWith<'a>(&'a Vec<AccessibilitySummaryProperty>);
1957					impl<'a> Serialize for SerializeWith<'a> {
1958						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1959						where
1960							S: Serializer,
1961						{
1962							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1963								self.0, serializer,
1964							)
1965						}
1966					}
1967					&SerializeWith(&self.r#accessibility_summary)
1968				})?;
1969			} else {
1970				serialize_struct.skip_field("accessibilitySummary")?;
1971			}
1972			if !Vec::is_empty(&self.r#accountable_person) {
1973				serialize_struct.serialize_field("accountablePerson", {
1974					struct SerializeWith<'a>(&'a Vec<AccountablePersonProperty>);
1975					impl<'a> Serialize for SerializeWith<'a> {
1976						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1977						where
1978							S: Serializer,
1979						{
1980							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1981								self.0, serializer,
1982							)
1983						}
1984					}
1985					&SerializeWith(&self.r#accountable_person)
1986				})?;
1987			} else {
1988				serialize_struct.skip_field("accountablePerson")?;
1989			}
1990			if !Vec::is_empty(&self.r#acquire_license_page) {
1991				serialize_struct.serialize_field("acquireLicensePage", {
1992					struct SerializeWith<'a>(&'a Vec<AcquireLicensePageProperty>);
1993					impl<'a> Serialize for SerializeWith<'a> {
1994						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1995						where
1996							S: Serializer,
1997						{
1998							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1999								self.0, serializer,
2000							)
2001						}
2002					}
2003					&SerializeWith(&self.r#acquire_license_page)
2004				})?;
2005			} else {
2006				serialize_struct.skip_field("acquireLicensePage")?;
2007			}
2008			if !Vec::is_empty(&self.r#aggregate_rating) {
2009				serialize_struct.serialize_field("aggregateRating", {
2010					struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
2011					impl<'a> Serialize for SerializeWith<'a> {
2012						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2013						where
2014							S: Serializer,
2015						{
2016							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2017								self.0, serializer,
2018							)
2019						}
2020					}
2021					&SerializeWith(&self.r#aggregate_rating)
2022				})?;
2023			} else {
2024				serialize_struct.skip_field("aggregateRating")?;
2025			}
2026			if !Vec::is_empty(&self.r#alternative_headline) {
2027				serialize_struct.serialize_field("alternativeHeadline", {
2028					struct SerializeWith<'a>(&'a Vec<AlternativeHeadlineProperty>);
2029					impl<'a> Serialize for SerializeWith<'a> {
2030						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2031						where
2032							S: Serializer,
2033						{
2034							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2035								self.0, serializer,
2036							)
2037						}
2038					}
2039					&SerializeWith(&self.r#alternative_headline)
2040				})?;
2041			} else {
2042				serialize_struct.skip_field("alternativeHeadline")?;
2043			}
2044			if !Vec::is_empty(&self.r#archived_at) {
2045				serialize_struct.serialize_field("archivedAt", {
2046					struct SerializeWith<'a>(&'a Vec<ArchivedAtProperty>);
2047					impl<'a> Serialize for SerializeWith<'a> {
2048						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2049						where
2050							S: Serializer,
2051						{
2052							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2053								self.0, serializer,
2054							)
2055						}
2056					}
2057					&SerializeWith(&self.r#archived_at)
2058				})?;
2059			} else {
2060				serialize_struct.skip_field("archivedAt")?;
2061			}
2062			if !Vec::is_empty(&self.r#assesses) {
2063				serialize_struct.serialize_field("assesses", {
2064					struct SerializeWith<'a>(&'a Vec<AssessesProperty>);
2065					impl<'a> Serialize for SerializeWith<'a> {
2066						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2067						where
2068							S: Serializer,
2069						{
2070							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2071								self.0, serializer,
2072							)
2073						}
2074					}
2075					&SerializeWith(&self.r#assesses)
2076				})?;
2077			} else {
2078				serialize_struct.skip_field("assesses")?;
2079			}
2080			if !Vec::is_empty(&self.r#associated_media) {
2081				serialize_struct.serialize_field("associatedMedia", {
2082					struct SerializeWith<'a>(&'a Vec<AssociatedMediaProperty>);
2083					impl<'a> Serialize for SerializeWith<'a> {
2084						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2085						where
2086							S: Serializer,
2087						{
2088							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2089								self.0, serializer,
2090							)
2091						}
2092					}
2093					&SerializeWith(&self.r#associated_media)
2094				})?;
2095			} else {
2096				serialize_struct.skip_field("associatedMedia")?;
2097			}
2098			if !Vec::is_empty(&self.r#audience) {
2099				serialize_struct.serialize_field("audience", {
2100					struct SerializeWith<'a>(&'a Vec<AudienceProperty>);
2101					impl<'a> Serialize for SerializeWith<'a> {
2102						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2103						where
2104							S: Serializer,
2105						{
2106							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2107								self.0, serializer,
2108							)
2109						}
2110					}
2111					&SerializeWith(&self.r#audience)
2112				})?;
2113			} else {
2114				serialize_struct.skip_field("audience")?;
2115			}
2116			if !Vec::is_empty(&self.r#audio) {
2117				serialize_struct.serialize_field("audio", {
2118					struct SerializeWith<'a>(&'a Vec<AudioProperty>);
2119					impl<'a> Serialize for SerializeWith<'a> {
2120						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2121						where
2122							S: Serializer,
2123						{
2124							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2125								self.0, serializer,
2126							)
2127						}
2128					}
2129					&SerializeWith(&self.r#audio)
2130				})?;
2131			} else {
2132				serialize_struct.skip_field("audio")?;
2133			}
2134			if !Vec::is_empty(&self.r#author) {
2135				serialize_struct.serialize_field("author", {
2136					struct SerializeWith<'a>(&'a Vec<AuthorProperty>);
2137					impl<'a> Serialize for SerializeWith<'a> {
2138						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2139						where
2140							S: Serializer,
2141						{
2142							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2143								self.0, serializer,
2144							)
2145						}
2146					}
2147					&SerializeWith(&self.r#author)
2148				})?;
2149			} else {
2150				serialize_struct.skip_field("author")?;
2151			}
2152			if !Vec::is_empty(&self.r#award) {
2153				serialize_struct.serialize_field("award", {
2154					struct SerializeWith<'a>(&'a Vec<AwardProperty>);
2155					impl<'a> Serialize for SerializeWith<'a> {
2156						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2157						where
2158							S: Serializer,
2159						{
2160							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2161								self.0, serializer,
2162							)
2163						}
2164					}
2165					&SerializeWith(&self.r#award)
2166				})?;
2167			} else {
2168				serialize_struct.skip_field("award")?;
2169			}
2170			if !Vec::is_empty(&self.r#awards) {
2171				serialize_struct.serialize_field("awards", {
2172					struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
2173					impl<'a> Serialize for SerializeWith<'a> {
2174						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2175						where
2176							S: Serializer,
2177						{
2178							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2179								self.0, serializer,
2180							)
2181						}
2182					}
2183					&SerializeWith(&self.r#awards)
2184				})?;
2185			} else {
2186				serialize_struct.skip_field("awards")?;
2187			}
2188			if !Vec::is_empty(&self.r#character) {
2189				serialize_struct.serialize_field("character", {
2190					struct SerializeWith<'a>(&'a Vec<CharacterProperty>);
2191					impl<'a> Serialize for SerializeWith<'a> {
2192						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2193						where
2194							S: Serializer,
2195						{
2196							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2197								self.0, serializer,
2198							)
2199						}
2200					}
2201					&SerializeWith(&self.r#character)
2202				})?;
2203			} else {
2204				serialize_struct.skip_field("character")?;
2205			}
2206			if !Vec::is_empty(&self.r#citation) {
2207				serialize_struct.serialize_field("citation", {
2208					struct SerializeWith<'a>(&'a Vec<CitationProperty>);
2209					impl<'a> Serialize for SerializeWith<'a> {
2210						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2211						where
2212							S: Serializer,
2213						{
2214							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2215								self.0, serializer,
2216							)
2217						}
2218					}
2219					&SerializeWith(&self.r#citation)
2220				})?;
2221			} else {
2222				serialize_struct.skip_field("citation")?;
2223			}
2224			if !Vec::is_empty(&self.r#comment) {
2225				serialize_struct.serialize_field("comment", {
2226					struct SerializeWith<'a>(&'a Vec<CommentProperty>);
2227					impl<'a> Serialize for SerializeWith<'a> {
2228						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2229						where
2230							S: Serializer,
2231						{
2232							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2233								self.0, serializer,
2234							)
2235						}
2236					}
2237					&SerializeWith(&self.r#comment)
2238				})?;
2239			} else {
2240				serialize_struct.skip_field("comment")?;
2241			}
2242			if !Vec::is_empty(&self.r#comment_count) {
2243				serialize_struct.serialize_field("commentCount", {
2244					struct SerializeWith<'a>(&'a Vec<CommentCountProperty>);
2245					impl<'a> Serialize for SerializeWith<'a> {
2246						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2247						where
2248							S: Serializer,
2249						{
2250							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2251								self.0, serializer,
2252							)
2253						}
2254					}
2255					&SerializeWith(&self.r#comment_count)
2256				})?;
2257			} else {
2258				serialize_struct.skip_field("commentCount")?;
2259			}
2260			if !Vec::is_empty(&self.r#conditions_of_access) {
2261				serialize_struct.serialize_field("conditionsOfAccess", {
2262					struct SerializeWith<'a>(&'a Vec<ConditionsOfAccessProperty>);
2263					impl<'a> Serialize for SerializeWith<'a> {
2264						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2265						where
2266							S: Serializer,
2267						{
2268							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2269								self.0, serializer,
2270							)
2271						}
2272					}
2273					&SerializeWith(&self.r#conditions_of_access)
2274				})?;
2275			} else {
2276				serialize_struct.skip_field("conditionsOfAccess")?;
2277			}
2278			if !Vec::is_empty(&self.r#content_location) {
2279				serialize_struct.serialize_field("contentLocation", {
2280					struct SerializeWith<'a>(&'a Vec<ContentLocationProperty>);
2281					impl<'a> Serialize for SerializeWith<'a> {
2282						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2283						where
2284							S: Serializer,
2285						{
2286							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2287								self.0, serializer,
2288							)
2289						}
2290					}
2291					&SerializeWith(&self.r#content_location)
2292				})?;
2293			} else {
2294				serialize_struct.skip_field("contentLocation")?;
2295			}
2296			if !Vec::is_empty(&self.r#content_rating) {
2297				serialize_struct.serialize_field("contentRating", {
2298					struct SerializeWith<'a>(&'a Vec<ContentRatingProperty>);
2299					impl<'a> Serialize for SerializeWith<'a> {
2300						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2301						where
2302							S: Serializer,
2303						{
2304							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2305								self.0, serializer,
2306							)
2307						}
2308					}
2309					&SerializeWith(&self.r#content_rating)
2310				})?;
2311			} else {
2312				serialize_struct.skip_field("contentRating")?;
2313			}
2314			if !Vec::is_empty(&self.r#content_reference_time) {
2315				serialize_struct.serialize_field("contentReferenceTime", {
2316					struct SerializeWith<'a>(&'a Vec<ContentReferenceTimeProperty>);
2317					impl<'a> Serialize for SerializeWith<'a> {
2318						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2319						where
2320							S: Serializer,
2321						{
2322							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2323								self.0, serializer,
2324							)
2325						}
2326					}
2327					&SerializeWith(&self.r#content_reference_time)
2328				})?;
2329			} else {
2330				serialize_struct.skip_field("contentReferenceTime")?;
2331			}
2332			if !Vec::is_empty(&self.r#contributor) {
2333				serialize_struct.serialize_field("contributor", {
2334					struct SerializeWith<'a>(&'a Vec<ContributorProperty>);
2335					impl<'a> Serialize for SerializeWith<'a> {
2336						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2337						where
2338							S: Serializer,
2339						{
2340							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2341								self.0, serializer,
2342							)
2343						}
2344					}
2345					&SerializeWith(&self.r#contributor)
2346				})?;
2347			} else {
2348				serialize_struct.skip_field("contributor")?;
2349			}
2350			if !Vec::is_empty(&self.r#copyright_holder) {
2351				serialize_struct.serialize_field("copyrightHolder", {
2352					struct SerializeWith<'a>(&'a Vec<CopyrightHolderProperty>);
2353					impl<'a> Serialize for SerializeWith<'a> {
2354						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2355						where
2356							S: Serializer,
2357						{
2358							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2359								self.0, serializer,
2360							)
2361						}
2362					}
2363					&SerializeWith(&self.r#copyright_holder)
2364				})?;
2365			} else {
2366				serialize_struct.skip_field("copyrightHolder")?;
2367			}
2368			if !Vec::is_empty(&self.r#copyright_notice) {
2369				serialize_struct.serialize_field("copyrightNotice", {
2370					struct SerializeWith<'a>(&'a Vec<CopyrightNoticeProperty>);
2371					impl<'a> Serialize for SerializeWith<'a> {
2372						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2373						where
2374							S: Serializer,
2375						{
2376							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2377								self.0, serializer,
2378							)
2379						}
2380					}
2381					&SerializeWith(&self.r#copyright_notice)
2382				})?;
2383			} else {
2384				serialize_struct.skip_field("copyrightNotice")?;
2385			}
2386			if !Vec::is_empty(&self.r#copyright_year) {
2387				serialize_struct.serialize_field("copyrightYear", {
2388					struct SerializeWith<'a>(&'a Vec<CopyrightYearProperty>);
2389					impl<'a> Serialize for SerializeWith<'a> {
2390						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2391						where
2392							S: Serializer,
2393						{
2394							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2395								self.0, serializer,
2396							)
2397						}
2398					}
2399					&SerializeWith(&self.r#copyright_year)
2400				})?;
2401			} else {
2402				serialize_struct.skip_field("copyrightYear")?;
2403			}
2404			if !Vec::is_empty(&self.r#correction) {
2405				serialize_struct.serialize_field("correction", {
2406					struct SerializeWith<'a>(&'a Vec<CorrectionProperty>);
2407					impl<'a> Serialize for SerializeWith<'a> {
2408						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2409						where
2410							S: Serializer,
2411						{
2412							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2413								self.0, serializer,
2414							)
2415						}
2416					}
2417					&SerializeWith(&self.r#correction)
2418				})?;
2419			} else {
2420				serialize_struct.skip_field("correction")?;
2421			}
2422			if !Vec::is_empty(&self.r#country_of_origin) {
2423				serialize_struct.serialize_field("countryOfOrigin", {
2424					struct SerializeWith<'a>(&'a Vec<CountryOfOriginProperty>);
2425					impl<'a> Serialize for SerializeWith<'a> {
2426						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2427						where
2428							S: Serializer,
2429						{
2430							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2431								self.0, serializer,
2432							)
2433						}
2434					}
2435					&SerializeWith(&self.r#country_of_origin)
2436				})?;
2437			} else {
2438				serialize_struct.skip_field("countryOfOrigin")?;
2439			}
2440			if !Vec::is_empty(&self.r#creative_work_status) {
2441				serialize_struct.serialize_field("creativeWorkStatus", {
2442					struct SerializeWith<'a>(&'a Vec<CreativeWorkStatusProperty>);
2443					impl<'a> Serialize for SerializeWith<'a> {
2444						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2445						where
2446							S: Serializer,
2447						{
2448							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2449								self.0, serializer,
2450							)
2451						}
2452					}
2453					&SerializeWith(&self.r#creative_work_status)
2454				})?;
2455			} else {
2456				serialize_struct.skip_field("creativeWorkStatus")?;
2457			}
2458			if !Vec::is_empty(&self.r#creator) {
2459				serialize_struct.serialize_field("creator", {
2460					struct SerializeWith<'a>(&'a Vec<CreatorProperty>);
2461					impl<'a> Serialize for SerializeWith<'a> {
2462						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2463						where
2464							S: Serializer,
2465						{
2466							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2467								self.0, serializer,
2468							)
2469						}
2470					}
2471					&SerializeWith(&self.r#creator)
2472				})?;
2473			} else {
2474				serialize_struct.skip_field("creator")?;
2475			}
2476			if !Vec::is_empty(&self.r#credit_text) {
2477				serialize_struct.serialize_field("creditText", {
2478					struct SerializeWith<'a>(&'a Vec<CreditTextProperty>);
2479					impl<'a> Serialize for SerializeWith<'a> {
2480						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2481						where
2482							S: Serializer,
2483						{
2484							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2485								self.0, serializer,
2486							)
2487						}
2488					}
2489					&SerializeWith(&self.r#credit_text)
2490				})?;
2491			} else {
2492				serialize_struct.skip_field("creditText")?;
2493			}
2494			if !Vec::is_empty(&self.r#date_created) {
2495				serialize_struct.serialize_field("dateCreated", {
2496					struct SerializeWith<'a>(&'a Vec<DateCreatedProperty>);
2497					impl<'a> Serialize for SerializeWith<'a> {
2498						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2499						where
2500							S: Serializer,
2501						{
2502							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2503								self.0, serializer,
2504							)
2505						}
2506					}
2507					&SerializeWith(&self.r#date_created)
2508				})?;
2509			} else {
2510				serialize_struct.skip_field("dateCreated")?;
2511			}
2512			if !Vec::is_empty(&self.r#date_modified) {
2513				serialize_struct.serialize_field("dateModified", {
2514					struct SerializeWith<'a>(&'a Vec<DateModifiedProperty>);
2515					impl<'a> Serialize for SerializeWith<'a> {
2516						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2517						where
2518							S: Serializer,
2519						{
2520							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2521								self.0, serializer,
2522							)
2523						}
2524					}
2525					&SerializeWith(&self.r#date_modified)
2526				})?;
2527			} else {
2528				serialize_struct.skip_field("dateModified")?;
2529			}
2530			if !Vec::is_empty(&self.r#date_published) {
2531				serialize_struct.serialize_field("datePublished", {
2532					struct SerializeWith<'a>(&'a Vec<DatePublishedProperty>);
2533					impl<'a> Serialize for SerializeWith<'a> {
2534						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2535						where
2536							S: Serializer,
2537						{
2538							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2539								self.0, serializer,
2540							)
2541						}
2542					}
2543					&SerializeWith(&self.r#date_published)
2544				})?;
2545			} else {
2546				serialize_struct.skip_field("datePublished")?;
2547			}
2548			if !Vec::is_empty(&self.r#discussion_url) {
2549				serialize_struct.serialize_field("discussionUrl", {
2550					struct SerializeWith<'a>(&'a Vec<DiscussionUrlProperty>);
2551					impl<'a> Serialize for SerializeWith<'a> {
2552						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2553						where
2554							S: Serializer,
2555						{
2556							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2557								self.0, serializer,
2558							)
2559						}
2560					}
2561					&SerializeWith(&self.r#discussion_url)
2562				})?;
2563			} else {
2564				serialize_struct.skip_field("discussionUrl")?;
2565			}
2566			if !Vec::is_empty(&self.r#edit_eidr) {
2567				serialize_struct.serialize_field("editEIDR", {
2568					struct SerializeWith<'a>(&'a Vec<EditEidrProperty>);
2569					impl<'a> Serialize for SerializeWith<'a> {
2570						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2571						where
2572							S: Serializer,
2573						{
2574							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2575								self.0, serializer,
2576							)
2577						}
2578					}
2579					&SerializeWith(&self.r#edit_eidr)
2580				})?;
2581			} else {
2582				serialize_struct.skip_field("editEIDR")?;
2583			}
2584			if !Vec::is_empty(&self.r#editor) {
2585				serialize_struct.serialize_field("editor", {
2586					struct SerializeWith<'a>(&'a Vec<EditorProperty>);
2587					impl<'a> Serialize for SerializeWith<'a> {
2588						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2589						where
2590							S: Serializer,
2591						{
2592							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2593								self.0, serializer,
2594							)
2595						}
2596					}
2597					&SerializeWith(&self.r#editor)
2598				})?;
2599			} else {
2600				serialize_struct.skip_field("editor")?;
2601			}
2602			if !Vec::is_empty(&self.r#educational_alignment) {
2603				serialize_struct.serialize_field("educationalAlignment", {
2604					struct SerializeWith<'a>(&'a Vec<EducationalAlignmentProperty>);
2605					impl<'a> Serialize for SerializeWith<'a> {
2606						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2607						where
2608							S: Serializer,
2609						{
2610							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2611								self.0, serializer,
2612							)
2613						}
2614					}
2615					&SerializeWith(&self.r#educational_alignment)
2616				})?;
2617			} else {
2618				serialize_struct.skip_field("educationalAlignment")?;
2619			}
2620			if !Vec::is_empty(&self.r#educational_level) {
2621				serialize_struct.serialize_field("educationalLevel", {
2622					struct SerializeWith<'a>(&'a Vec<EducationalLevelProperty>);
2623					impl<'a> Serialize for SerializeWith<'a> {
2624						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2625						where
2626							S: Serializer,
2627						{
2628							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2629								self.0, serializer,
2630							)
2631						}
2632					}
2633					&SerializeWith(&self.r#educational_level)
2634				})?;
2635			} else {
2636				serialize_struct.skip_field("educationalLevel")?;
2637			}
2638			if !Vec::is_empty(&self.r#educational_use) {
2639				serialize_struct.serialize_field("educationalUse", {
2640					struct SerializeWith<'a>(&'a Vec<EducationalUseProperty>);
2641					impl<'a> Serialize for SerializeWith<'a> {
2642						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2643						where
2644							S: Serializer,
2645						{
2646							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2647								self.0, serializer,
2648							)
2649						}
2650					}
2651					&SerializeWith(&self.r#educational_use)
2652				})?;
2653			} else {
2654				serialize_struct.skip_field("educationalUse")?;
2655			}
2656			if !Vec::is_empty(&self.r#encoding) {
2657				serialize_struct.serialize_field("encoding", {
2658					struct SerializeWith<'a>(&'a Vec<EncodingProperty>);
2659					impl<'a> Serialize for SerializeWith<'a> {
2660						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2661						where
2662							S: Serializer,
2663						{
2664							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2665								self.0, serializer,
2666							)
2667						}
2668					}
2669					&SerializeWith(&self.r#encoding)
2670				})?;
2671			} else {
2672				serialize_struct.skip_field("encoding")?;
2673			}
2674			if !Vec::is_empty(&self.r#encoding_format) {
2675				serialize_struct.serialize_field("encodingFormat", {
2676					struct SerializeWith<'a>(&'a Vec<EncodingFormatProperty>);
2677					impl<'a> Serialize for SerializeWith<'a> {
2678						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2679						where
2680							S: Serializer,
2681						{
2682							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2683								self.0, serializer,
2684							)
2685						}
2686					}
2687					&SerializeWith(&self.r#encoding_format)
2688				})?;
2689			} else {
2690				serialize_struct.skip_field("encodingFormat")?;
2691			}
2692			if !Vec::is_empty(&self.r#encodings) {
2693				serialize_struct.serialize_field("encodings", {
2694					struct SerializeWith<'a>(&'a Vec<EncodingsProperty>);
2695					impl<'a> Serialize for SerializeWith<'a> {
2696						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2697						where
2698							S: Serializer,
2699						{
2700							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2701								self.0, serializer,
2702							)
2703						}
2704					}
2705					&SerializeWith(&self.r#encodings)
2706				})?;
2707			} else {
2708				serialize_struct.skip_field("encodings")?;
2709			}
2710			if !Vec::is_empty(&self.r#example_of_work) {
2711				serialize_struct.serialize_field("exampleOfWork", {
2712					struct SerializeWith<'a>(&'a Vec<ExampleOfWorkProperty>);
2713					impl<'a> Serialize for SerializeWith<'a> {
2714						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2715						where
2716							S: Serializer,
2717						{
2718							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2719								self.0, serializer,
2720							)
2721						}
2722					}
2723					&SerializeWith(&self.r#example_of_work)
2724				})?;
2725			} else {
2726				serialize_struct.skip_field("exampleOfWork")?;
2727			}
2728			if !Vec::is_empty(&self.r#expires) {
2729				serialize_struct.serialize_field("expires", {
2730					struct SerializeWith<'a>(&'a Vec<ExpiresProperty>);
2731					impl<'a> Serialize for SerializeWith<'a> {
2732						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2733						where
2734							S: Serializer,
2735						{
2736							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2737								self.0, serializer,
2738							)
2739						}
2740					}
2741					&SerializeWith(&self.r#expires)
2742				})?;
2743			} else {
2744				serialize_struct.skip_field("expires")?;
2745			}
2746			if !Vec::is_empty(&self.r#file_format) {
2747				serialize_struct.serialize_field("fileFormat", {
2748					struct SerializeWith<'a>(&'a Vec<FileFormatProperty>);
2749					impl<'a> Serialize for SerializeWith<'a> {
2750						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2751						where
2752							S: Serializer,
2753						{
2754							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2755								self.0, serializer,
2756							)
2757						}
2758					}
2759					&SerializeWith(&self.r#file_format)
2760				})?;
2761			} else {
2762				serialize_struct.skip_field("fileFormat")?;
2763			}
2764			if !Vec::is_empty(&self.r#funder) {
2765				serialize_struct.serialize_field("funder", {
2766					struct SerializeWith<'a>(&'a Vec<FunderProperty>);
2767					impl<'a> Serialize for SerializeWith<'a> {
2768						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2769						where
2770							S: Serializer,
2771						{
2772							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2773								self.0, serializer,
2774							)
2775						}
2776					}
2777					&SerializeWith(&self.r#funder)
2778				})?;
2779			} else {
2780				serialize_struct.skip_field("funder")?;
2781			}
2782			if !Vec::is_empty(&self.r#funding) {
2783				serialize_struct.serialize_field("funding", {
2784					struct SerializeWith<'a>(&'a Vec<FundingProperty>);
2785					impl<'a> Serialize for SerializeWith<'a> {
2786						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2787						where
2788							S: Serializer,
2789						{
2790							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2791								self.0, serializer,
2792							)
2793						}
2794					}
2795					&SerializeWith(&self.r#funding)
2796				})?;
2797			} else {
2798				serialize_struct.skip_field("funding")?;
2799			}
2800			if !Vec::is_empty(&self.r#genre) {
2801				serialize_struct.serialize_field("genre", {
2802					struct SerializeWith<'a>(&'a Vec<GenreProperty>);
2803					impl<'a> Serialize for SerializeWith<'a> {
2804						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2805						where
2806							S: Serializer,
2807						{
2808							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2809								self.0, serializer,
2810							)
2811						}
2812					}
2813					&SerializeWith(&self.r#genre)
2814				})?;
2815			} else {
2816				serialize_struct.skip_field("genre")?;
2817			}
2818			if !Vec::is_empty(&self.r#has_part) {
2819				serialize_struct.serialize_field("hasPart", {
2820					struct SerializeWith<'a>(&'a Vec<HasPartProperty>);
2821					impl<'a> Serialize for SerializeWith<'a> {
2822						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2823						where
2824							S: Serializer,
2825						{
2826							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2827								self.0, serializer,
2828							)
2829						}
2830					}
2831					&SerializeWith(&self.r#has_part)
2832				})?;
2833			} else {
2834				serialize_struct.skip_field("hasPart")?;
2835			}
2836			if !Vec::is_empty(&self.r#headline) {
2837				serialize_struct.serialize_field("headline", {
2838					struct SerializeWith<'a>(&'a Vec<HeadlineProperty>);
2839					impl<'a> Serialize for SerializeWith<'a> {
2840						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2841						where
2842							S: Serializer,
2843						{
2844							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2845								self.0, serializer,
2846							)
2847						}
2848					}
2849					&SerializeWith(&self.r#headline)
2850				})?;
2851			} else {
2852				serialize_struct.skip_field("headline")?;
2853			}
2854			if !Vec::is_empty(&self.r#in_language) {
2855				serialize_struct.serialize_field("inLanguage", {
2856					struct SerializeWith<'a>(&'a Vec<InLanguageProperty>);
2857					impl<'a> Serialize for SerializeWith<'a> {
2858						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2859						where
2860							S: Serializer,
2861						{
2862							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2863								self.0, serializer,
2864							)
2865						}
2866					}
2867					&SerializeWith(&self.r#in_language)
2868				})?;
2869			} else {
2870				serialize_struct.skip_field("inLanguage")?;
2871			}
2872			if !Vec::is_empty(&self.r#interaction_statistic) {
2873				serialize_struct.serialize_field("interactionStatistic", {
2874					struct SerializeWith<'a>(&'a Vec<InteractionStatisticProperty>);
2875					impl<'a> Serialize for SerializeWith<'a> {
2876						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2877						where
2878							S: Serializer,
2879						{
2880							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2881								self.0, serializer,
2882							)
2883						}
2884					}
2885					&SerializeWith(&self.r#interaction_statistic)
2886				})?;
2887			} else {
2888				serialize_struct.skip_field("interactionStatistic")?;
2889			}
2890			if !Vec::is_empty(&self.r#interactivity_type) {
2891				serialize_struct.serialize_field("interactivityType", {
2892					struct SerializeWith<'a>(&'a Vec<InteractivityTypeProperty>);
2893					impl<'a> Serialize for SerializeWith<'a> {
2894						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2895						where
2896							S: Serializer,
2897						{
2898							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2899								self.0, serializer,
2900							)
2901						}
2902					}
2903					&SerializeWith(&self.r#interactivity_type)
2904				})?;
2905			} else {
2906				serialize_struct.skip_field("interactivityType")?;
2907			}
2908			if !Vec::is_empty(&self.r#interpreted_as_claim) {
2909				serialize_struct.serialize_field("interpretedAsClaim", {
2910					struct SerializeWith<'a>(&'a Vec<InterpretedAsClaimProperty>);
2911					impl<'a> Serialize for SerializeWith<'a> {
2912						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2913						where
2914							S: Serializer,
2915						{
2916							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2917								self.0, serializer,
2918							)
2919						}
2920					}
2921					&SerializeWith(&self.r#interpreted_as_claim)
2922				})?;
2923			} else {
2924				serialize_struct.skip_field("interpretedAsClaim")?;
2925			}
2926			if !Vec::is_empty(&self.r#is_accessible_for_free) {
2927				serialize_struct.serialize_field("isAccessibleForFree", {
2928					struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
2929					impl<'a> Serialize for SerializeWith<'a> {
2930						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2931						where
2932							S: Serializer,
2933						{
2934							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2935								self.0, serializer,
2936							)
2937						}
2938					}
2939					&SerializeWith(&self.r#is_accessible_for_free)
2940				})?;
2941			} else {
2942				serialize_struct.skip_field("isAccessibleForFree")?;
2943			}
2944			if !Vec::is_empty(&self.r#is_based_on) {
2945				serialize_struct.serialize_field("isBasedOn", {
2946					struct SerializeWith<'a>(&'a Vec<IsBasedOnProperty>);
2947					impl<'a> Serialize for SerializeWith<'a> {
2948						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2949						where
2950							S: Serializer,
2951						{
2952							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2953								self.0, serializer,
2954							)
2955						}
2956					}
2957					&SerializeWith(&self.r#is_based_on)
2958				})?;
2959			} else {
2960				serialize_struct.skip_field("isBasedOn")?;
2961			}
2962			if !Vec::is_empty(&self.r#is_based_on_url) {
2963				serialize_struct.serialize_field("isBasedOnUrl", {
2964					struct SerializeWith<'a>(&'a Vec<IsBasedOnUrlProperty>);
2965					impl<'a> Serialize for SerializeWith<'a> {
2966						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2967						where
2968							S: Serializer,
2969						{
2970							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2971								self.0, serializer,
2972							)
2973						}
2974					}
2975					&SerializeWith(&self.r#is_based_on_url)
2976				})?;
2977			} else {
2978				serialize_struct.skip_field("isBasedOnUrl")?;
2979			}
2980			if !Vec::is_empty(&self.r#is_family_friendly) {
2981				serialize_struct.serialize_field("isFamilyFriendly", {
2982					struct SerializeWith<'a>(&'a Vec<IsFamilyFriendlyProperty>);
2983					impl<'a> Serialize for SerializeWith<'a> {
2984						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2985						where
2986							S: Serializer,
2987						{
2988							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2989								self.0, serializer,
2990							)
2991						}
2992					}
2993					&SerializeWith(&self.r#is_family_friendly)
2994				})?;
2995			} else {
2996				serialize_struct.skip_field("isFamilyFriendly")?;
2997			}
2998			if !Vec::is_empty(&self.r#is_part_of) {
2999				serialize_struct.serialize_field("isPartOf", {
3000					struct SerializeWith<'a>(&'a Vec<IsPartOfProperty>);
3001					impl<'a> Serialize for SerializeWith<'a> {
3002						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3003						where
3004							S: Serializer,
3005						{
3006							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3007								self.0, serializer,
3008							)
3009						}
3010					}
3011					&SerializeWith(&self.r#is_part_of)
3012				})?;
3013			} else {
3014				serialize_struct.skip_field("isPartOf")?;
3015			}
3016			if !Vec::is_empty(&self.r#keywords) {
3017				serialize_struct.serialize_field("keywords", {
3018					struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
3019					impl<'a> Serialize for SerializeWith<'a> {
3020						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3021						where
3022							S: Serializer,
3023						{
3024							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3025								self.0, serializer,
3026							)
3027						}
3028					}
3029					&SerializeWith(&self.r#keywords)
3030				})?;
3031			} else {
3032				serialize_struct.skip_field("keywords")?;
3033			}
3034			if !Vec::is_empty(&self.r#learning_resource_type) {
3035				serialize_struct.serialize_field("learningResourceType", {
3036					struct SerializeWith<'a>(&'a Vec<LearningResourceTypeProperty>);
3037					impl<'a> Serialize for SerializeWith<'a> {
3038						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3039						where
3040							S: Serializer,
3041						{
3042							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3043								self.0, serializer,
3044							)
3045						}
3046					}
3047					&SerializeWith(&self.r#learning_resource_type)
3048				})?;
3049			} else {
3050				serialize_struct.skip_field("learningResourceType")?;
3051			}
3052			if !Vec::is_empty(&self.r#license) {
3053				serialize_struct.serialize_field("license", {
3054					struct SerializeWith<'a>(&'a Vec<LicenseProperty>);
3055					impl<'a> Serialize for SerializeWith<'a> {
3056						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3057						where
3058							S: Serializer,
3059						{
3060							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3061								self.0, serializer,
3062							)
3063						}
3064					}
3065					&SerializeWith(&self.r#license)
3066				})?;
3067			} else {
3068				serialize_struct.skip_field("license")?;
3069			}
3070			if !Vec::is_empty(&self.r#location_created) {
3071				serialize_struct.serialize_field("locationCreated", {
3072					struct SerializeWith<'a>(&'a Vec<LocationCreatedProperty>);
3073					impl<'a> Serialize for SerializeWith<'a> {
3074						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3075						where
3076							S: Serializer,
3077						{
3078							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3079								self.0, serializer,
3080							)
3081						}
3082					}
3083					&SerializeWith(&self.r#location_created)
3084				})?;
3085			} else {
3086				serialize_struct.skip_field("locationCreated")?;
3087			}
3088			if !Vec::is_empty(&self.r#main_entity) {
3089				serialize_struct.serialize_field("mainEntity", {
3090					struct SerializeWith<'a>(&'a Vec<MainEntityProperty>);
3091					impl<'a> Serialize for SerializeWith<'a> {
3092						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3093						where
3094							S: Serializer,
3095						{
3096							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3097								self.0, serializer,
3098							)
3099						}
3100					}
3101					&SerializeWith(&self.r#main_entity)
3102				})?;
3103			} else {
3104				serialize_struct.skip_field("mainEntity")?;
3105			}
3106			if !Vec::is_empty(&self.r#maintainer) {
3107				serialize_struct.serialize_field("maintainer", {
3108					struct SerializeWith<'a>(&'a Vec<MaintainerProperty>);
3109					impl<'a> Serialize for SerializeWith<'a> {
3110						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3111						where
3112							S: Serializer,
3113						{
3114							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3115								self.0, serializer,
3116							)
3117						}
3118					}
3119					&SerializeWith(&self.r#maintainer)
3120				})?;
3121			} else {
3122				serialize_struct.skip_field("maintainer")?;
3123			}
3124			if !Vec::is_empty(&self.r#material) {
3125				serialize_struct.serialize_field("material", {
3126					struct SerializeWith<'a>(&'a Vec<MaterialProperty>);
3127					impl<'a> Serialize for SerializeWith<'a> {
3128						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3129						where
3130							S: Serializer,
3131						{
3132							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3133								self.0, serializer,
3134							)
3135						}
3136					}
3137					&SerializeWith(&self.r#material)
3138				})?;
3139			} else {
3140				serialize_struct.skip_field("material")?;
3141			}
3142			if !Vec::is_empty(&self.r#material_extent) {
3143				serialize_struct.serialize_field("materialExtent", {
3144					struct SerializeWith<'a>(&'a Vec<MaterialExtentProperty>);
3145					impl<'a> Serialize for SerializeWith<'a> {
3146						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3147						where
3148							S: Serializer,
3149						{
3150							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3151								self.0, serializer,
3152							)
3153						}
3154					}
3155					&SerializeWith(&self.r#material_extent)
3156				})?;
3157			} else {
3158				serialize_struct.skip_field("materialExtent")?;
3159			}
3160			if !Vec::is_empty(&self.r#mentions) {
3161				serialize_struct.serialize_field("mentions", {
3162					struct SerializeWith<'a>(&'a Vec<MentionsProperty>);
3163					impl<'a> Serialize for SerializeWith<'a> {
3164						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3165						where
3166							S: Serializer,
3167						{
3168							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3169								self.0, serializer,
3170							)
3171						}
3172					}
3173					&SerializeWith(&self.r#mentions)
3174				})?;
3175			} else {
3176				serialize_struct.skip_field("mentions")?;
3177			}
3178			if !Vec::is_empty(&self.r#offers) {
3179				serialize_struct.serialize_field("offers", {
3180					struct SerializeWith<'a>(&'a Vec<OffersProperty>);
3181					impl<'a> Serialize for SerializeWith<'a> {
3182						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3183						where
3184							S: Serializer,
3185						{
3186							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3187								self.0, serializer,
3188							)
3189						}
3190					}
3191					&SerializeWith(&self.r#offers)
3192				})?;
3193			} else {
3194				serialize_struct.skip_field("offers")?;
3195			}
3196			if !Vec::is_empty(&self.r#pattern) {
3197				serialize_struct.serialize_field("pattern", {
3198					struct SerializeWith<'a>(&'a Vec<PatternProperty>);
3199					impl<'a> Serialize for SerializeWith<'a> {
3200						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3201						where
3202							S: Serializer,
3203						{
3204							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3205								self.0, serializer,
3206							)
3207						}
3208					}
3209					&SerializeWith(&self.r#pattern)
3210				})?;
3211			} else {
3212				serialize_struct.skip_field("pattern")?;
3213			}
3214			if !Vec::is_empty(&self.r#position) {
3215				serialize_struct.serialize_field("position", {
3216					struct SerializeWith<'a>(&'a Vec<PositionProperty>);
3217					impl<'a> Serialize for SerializeWith<'a> {
3218						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3219						where
3220							S: Serializer,
3221						{
3222							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3223								self.0, serializer,
3224							)
3225						}
3226					}
3227					&SerializeWith(&self.r#position)
3228				})?;
3229			} else {
3230				serialize_struct.skip_field("position")?;
3231			}
3232			if !Vec::is_empty(&self.r#producer) {
3233				serialize_struct.serialize_field("producer", {
3234					struct SerializeWith<'a>(&'a Vec<ProducerProperty>);
3235					impl<'a> Serialize for SerializeWith<'a> {
3236						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3237						where
3238							S: Serializer,
3239						{
3240							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3241								self.0, serializer,
3242							)
3243						}
3244					}
3245					&SerializeWith(&self.r#producer)
3246				})?;
3247			} else {
3248				serialize_struct.skip_field("producer")?;
3249			}
3250			if !Vec::is_empty(&self.r#provider) {
3251				serialize_struct.serialize_field("provider", {
3252					struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
3253					impl<'a> Serialize for SerializeWith<'a> {
3254						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3255						where
3256							S: Serializer,
3257						{
3258							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3259								self.0, serializer,
3260							)
3261						}
3262					}
3263					&SerializeWith(&self.r#provider)
3264				})?;
3265			} else {
3266				serialize_struct.skip_field("provider")?;
3267			}
3268			if !Vec::is_empty(&self.r#publication) {
3269				serialize_struct.serialize_field("publication", {
3270					struct SerializeWith<'a>(&'a Vec<PublicationProperty>);
3271					impl<'a> Serialize for SerializeWith<'a> {
3272						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3273						where
3274							S: Serializer,
3275						{
3276							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3277								self.0, serializer,
3278							)
3279						}
3280					}
3281					&SerializeWith(&self.r#publication)
3282				})?;
3283			} else {
3284				serialize_struct.skip_field("publication")?;
3285			}
3286			if !Vec::is_empty(&self.r#publisher) {
3287				serialize_struct.serialize_field("publisher", {
3288					struct SerializeWith<'a>(&'a Vec<PublisherProperty>);
3289					impl<'a> Serialize for SerializeWith<'a> {
3290						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3291						where
3292							S: Serializer,
3293						{
3294							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3295								self.0, serializer,
3296							)
3297						}
3298					}
3299					&SerializeWith(&self.r#publisher)
3300				})?;
3301			} else {
3302				serialize_struct.skip_field("publisher")?;
3303			}
3304			if !Vec::is_empty(&self.r#publisher_imprint) {
3305				serialize_struct.serialize_field("publisherImprint", {
3306					struct SerializeWith<'a>(&'a Vec<PublisherImprintProperty>);
3307					impl<'a> Serialize for SerializeWith<'a> {
3308						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3309						where
3310							S: Serializer,
3311						{
3312							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3313								self.0, serializer,
3314							)
3315						}
3316					}
3317					&SerializeWith(&self.r#publisher_imprint)
3318				})?;
3319			} else {
3320				serialize_struct.skip_field("publisherImprint")?;
3321			}
3322			if !Vec::is_empty(&self.r#publishing_principles) {
3323				serialize_struct.serialize_field("publishingPrinciples", {
3324					struct SerializeWith<'a>(&'a Vec<PublishingPrinciplesProperty>);
3325					impl<'a> Serialize for SerializeWith<'a> {
3326						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3327						where
3328							S: Serializer,
3329						{
3330							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3331								self.0, serializer,
3332							)
3333						}
3334					}
3335					&SerializeWith(&self.r#publishing_principles)
3336				})?;
3337			} else {
3338				serialize_struct.skip_field("publishingPrinciples")?;
3339			}
3340			if !Vec::is_empty(&self.r#recorded_at) {
3341				serialize_struct.serialize_field("recordedAt", {
3342					struct SerializeWith<'a>(&'a Vec<RecordedAtProperty>);
3343					impl<'a> Serialize for SerializeWith<'a> {
3344						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3345						where
3346							S: Serializer,
3347						{
3348							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3349								self.0, serializer,
3350							)
3351						}
3352					}
3353					&SerializeWith(&self.r#recorded_at)
3354				})?;
3355			} else {
3356				serialize_struct.skip_field("recordedAt")?;
3357			}
3358			if !Vec::is_empty(&self.r#released_event) {
3359				serialize_struct.serialize_field("releasedEvent", {
3360					struct SerializeWith<'a>(&'a Vec<ReleasedEventProperty>);
3361					impl<'a> Serialize for SerializeWith<'a> {
3362						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3363						where
3364							S: Serializer,
3365						{
3366							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3367								self.0, serializer,
3368							)
3369						}
3370					}
3371					&SerializeWith(&self.r#released_event)
3372				})?;
3373			} else {
3374				serialize_struct.skip_field("releasedEvent")?;
3375			}
3376			if !Vec::is_empty(&self.r#review) {
3377				serialize_struct.serialize_field("review", {
3378					struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
3379					impl<'a> Serialize for SerializeWith<'a> {
3380						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3381						where
3382							S: Serializer,
3383						{
3384							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3385								self.0, serializer,
3386							)
3387						}
3388					}
3389					&SerializeWith(&self.r#review)
3390				})?;
3391			} else {
3392				serialize_struct.skip_field("review")?;
3393			}
3394			if !Vec::is_empty(&self.r#reviews) {
3395				serialize_struct.serialize_field("reviews", {
3396					struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
3397					impl<'a> Serialize for SerializeWith<'a> {
3398						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3399						where
3400							S: Serializer,
3401						{
3402							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3403								self.0, serializer,
3404							)
3405						}
3406					}
3407					&SerializeWith(&self.r#reviews)
3408				})?;
3409			} else {
3410				serialize_struct.skip_field("reviews")?;
3411			}
3412			if !Vec::is_empty(&self.r#schema_version) {
3413				serialize_struct.serialize_field("schemaVersion", {
3414					struct SerializeWith<'a>(&'a Vec<SchemaVersionProperty>);
3415					impl<'a> Serialize for SerializeWith<'a> {
3416						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3417						where
3418							S: Serializer,
3419						{
3420							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3421								self.0, serializer,
3422							)
3423						}
3424					}
3425					&SerializeWith(&self.r#schema_version)
3426				})?;
3427			} else {
3428				serialize_struct.skip_field("schemaVersion")?;
3429			}
3430			if !Vec::is_empty(&self.r#sd_date_published) {
3431				serialize_struct.serialize_field("sdDatePublished", {
3432					struct SerializeWith<'a>(&'a Vec<SdDatePublishedProperty>);
3433					impl<'a> Serialize for SerializeWith<'a> {
3434						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3435						where
3436							S: Serializer,
3437						{
3438							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3439								self.0, serializer,
3440							)
3441						}
3442					}
3443					&SerializeWith(&self.r#sd_date_published)
3444				})?;
3445			} else {
3446				serialize_struct.skip_field("sdDatePublished")?;
3447			}
3448			if !Vec::is_empty(&self.r#sd_license) {
3449				serialize_struct.serialize_field("sdLicense", {
3450					struct SerializeWith<'a>(&'a Vec<SdLicenseProperty>);
3451					impl<'a> Serialize for SerializeWith<'a> {
3452						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3453						where
3454							S: Serializer,
3455						{
3456							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3457								self.0, serializer,
3458							)
3459						}
3460					}
3461					&SerializeWith(&self.r#sd_license)
3462				})?;
3463			} else {
3464				serialize_struct.skip_field("sdLicense")?;
3465			}
3466			if !Vec::is_empty(&self.r#sd_publisher) {
3467				serialize_struct.serialize_field("sdPublisher", {
3468					struct SerializeWith<'a>(&'a Vec<SdPublisherProperty>);
3469					impl<'a> Serialize for SerializeWith<'a> {
3470						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3471						where
3472							S: Serializer,
3473						{
3474							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3475								self.0, serializer,
3476							)
3477						}
3478					}
3479					&SerializeWith(&self.r#sd_publisher)
3480				})?;
3481			} else {
3482				serialize_struct.skip_field("sdPublisher")?;
3483			}
3484			if !Vec::is_empty(&self.r#size) {
3485				serialize_struct.serialize_field("size", {
3486					struct SerializeWith<'a>(&'a Vec<SizeProperty>);
3487					impl<'a> Serialize for SerializeWith<'a> {
3488						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3489						where
3490							S: Serializer,
3491						{
3492							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3493								self.0, serializer,
3494							)
3495						}
3496					}
3497					&SerializeWith(&self.r#size)
3498				})?;
3499			} else {
3500				serialize_struct.skip_field("size")?;
3501			}
3502			if !Vec::is_empty(&self.r#source_organization) {
3503				serialize_struct.serialize_field("sourceOrganization", {
3504					struct SerializeWith<'a>(&'a Vec<SourceOrganizationProperty>);
3505					impl<'a> Serialize for SerializeWith<'a> {
3506						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3507						where
3508							S: Serializer,
3509						{
3510							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3511								self.0, serializer,
3512							)
3513						}
3514					}
3515					&SerializeWith(&self.r#source_organization)
3516				})?;
3517			} else {
3518				serialize_struct.skip_field("sourceOrganization")?;
3519			}
3520			if !Vec::is_empty(&self.r#spatial) {
3521				serialize_struct.serialize_field("spatial", {
3522					struct SerializeWith<'a>(&'a Vec<SpatialProperty>);
3523					impl<'a> Serialize for SerializeWith<'a> {
3524						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3525						where
3526							S: Serializer,
3527						{
3528							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3529								self.0, serializer,
3530							)
3531						}
3532					}
3533					&SerializeWith(&self.r#spatial)
3534				})?;
3535			} else {
3536				serialize_struct.skip_field("spatial")?;
3537			}
3538			if !Vec::is_empty(&self.r#spatial_coverage) {
3539				serialize_struct.serialize_field("spatialCoverage", {
3540					struct SerializeWith<'a>(&'a Vec<SpatialCoverageProperty>);
3541					impl<'a> Serialize for SerializeWith<'a> {
3542						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3543						where
3544							S: Serializer,
3545						{
3546							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3547								self.0, serializer,
3548							)
3549						}
3550					}
3551					&SerializeWith(&self.r#spatial_coverage)
3552				})?;
3553			} else {
3554				serialize_struct.skip_field("spatialCoverage")?;
3555			}
3556			if !Vec::is_empty(&self.r#sponsor) {
3557				serialize_struct.serialize_field("sponsor", {
3558					struct SerializeWith<'a>(&'a Vec<SponsorProperty>);
3559					impl<'a> Serialize for SerializeWith<'a> {
3560						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3561						where
3562							S: Serializer,
3563						{
3564							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3565								self.0, serializer,
3566							)
3567						}
3568					}
3569					&SerializeWith(&self.r#sponsor)
3570				})?;
3571			} else {
3572				serialize_struct.skip_field("sponsor")?;
3573			}
3574			if !Vec::is_empty(&self.r#teaches) {
3575				serialize_struct.serialize_field("teaches", {
3576					struct SerializeWith<'a>(&'a Vec<TeachesProperty>);
3577					impl<'a> Serialize for SerializeWith<'a> {
3578						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3579						where
3580							S: Serializer,
3581						{
3582							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3583								self.0, serializer,
3584							)
3585						}
3586					}
3587					&SerializeWith(&self.r#teaches)
3588				})?;
3589			} else {
3590				serialize_struct.skip_field("teaches")?;
3591			}
3592			if !Vec::is_empty(&self.r#temporal) {
3593				serialize_struct.serialize_field("temporal", {
3594					struct SerializeWith<'a>(&'a Vec<TemporalProperty>);
3595					impl<'a> Serialize for SerializeWith<'a> {
3596						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3597						where
3598							S: Serializer,
3599						{
3600							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3601								self.0, serializer,
3602							)
3603						}
3604					}
3605					&SerializeWith(&self.r#temporal)
3606				})?;
3607			} else {
3608				serialize_struct.skip_field("temporal")?;
3609			}
3610			if !Vec::is_empty(&self.r#temporal_coverage) {
3611				serialize_struct.serialize_field("temporalCoverage", {
3612					struct SerializeWith<'a>(&'a Vec<TemporalCoverageProperty>);
3613					impl<'a> Serialize for SerializeWith<'a> {
3614						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3615						where
3616							S: Serializer,
3617						{
3618							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3619								self.0, serializer,
3620							)
3621						}
3622					}
3623					&SerializeWith(&self.r#temporal_coverage)
3624				})?;
3625			} else {
3626				serialize_struct.skip_field("temporalCoverage")?;
3627			}
3628			if !Vec::is_empty(&self.r#text) {
3629				serialize_struct.serialize_field("text", {
3630					struct SerializeWith<'a>(&'a Vec<TextProperty>);
3631					impl<'a> Serialize for SerializeWith<'a> {
3632						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3633						where
3634							S: Serializer,
3635						{
3636							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3637								self.0, serializer,
3638							)
3639						}
3640					}
3641					&SerializeWith(&self.r#text)
3642				})?;
3643			} else {
3644				serialize_struct.skip_field("text")?;
3645			}
3646			if !Vec::is_empty(&self.r#thumbnail) {
3647				serialize_struct.serialize_field("thumbnail", {
3648					struct SerializeWith<'a>(&'a Vec<ThumbnailProperty>);
3649					impl<'a> Serialize for SerializeWith<'a> {
3650						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3651						where
3652							S: Serializer,
3653						{
3654							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3655								self.0, serializer,
3656							)
3657						}
3658					}
3659					&SerializeWith(&self.r#thumbnail)
3660				})?;
3661			} else {
3662				serialize_struct.skip_field("thumbnail")?;
3663			}
3664			if !Vec::is_empty(&self.r#thumbnail_url) {
3665				serialize_struct.serialize_field("thumbnailUrl", {
3666					struct SerializeWith<'a>(&'a Vec<ThumbnailUrlProperty>);
3667					impl<'a> Serialize for SerializeWith<'a> {
3668						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3669						where
3670							S: Serializer,
3671						{
3672							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3673								self.0, serializer,
3674							)
3675						}
3676					}
3677					&SerializeWith(&self.r#thumbnail_url)
3678				})?;
3679			} else {
3680				serialize_struct.skip_field("thumbnailUrl")?;
3681			}
3682			if !Vec::is_empty(&self.r#time_required) {
3683				serialize_struct.serialize_field("timeRequired", {
3684					struct SerializeWith<'a>(&'a Vec<TimeRequiredProperty>);
3685					impl<'a> Serialize for SerializeWith<'a> {
3686						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3687						where
3688							S: Serializer,
3689						{
3690							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3691								self.0, serializer,
3692							)
3693						}
3694					}
3695					&SerializeWith(&self.r#time_required)
3696				})?;
3697			} else {
3698				serialize_struct.skip_field("timeRequired")?;
3699			}
3700			if !Vec::is_empty(&self.r#translation_of_work) {
3701				serialize_struct.serialize_field("translationOfWork", {
3702					struct SerializeWith<'a>(&'a Vec<TranslationOfWorkProperty>);
3703					impl<'a> Serialize for SerializeWith<'a> {
3704						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3705						where
3706							S: Serializer,
3707						{
3708							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3709								self.0, serializer,
3710							)
3711						}
3712					}
3713					&SerializeWith(&self.r#translation_of_work)
3714				})?;
3715			} else {
3716				serialize_struct.skip_field("translationOfWork")?;
3717			}
3718			if !Vec::is_empty(&self.r#translator) {
3719				serialize_struct.serialize_field("translator", {
3720					struct SerializeWith<'a>(&'a Vec<TranslatorProperty>);
3721					impl<'a> Serialize for SerializeWith<'a> {
3722						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3723						where
3724							S: Serializer,
3725						{
3726							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3727								self.0, serializer,
3728							)
3729						}
3730					}
3731					&SerializeWith(&self.r#translator)
3732				})?;
3733			} else {
3734				serialize_struct.skip_field("translator")?;
3735			}
3736			if !Vec::is_empty(&self.r#typical_age_range) {
3737				serialize_struct.serialize_field("typicalAgeRange", {
3738					struct SerializeWith<'a>(&'a Vec<TypicalAgeRangeProperty>);
3739					impl<'a> Serialize for SerializeWith<'a> {
3740						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3741						where
3742							S: Serializer,
3743						{
3744							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3745								self.0, serializer,
3746							)
3747						}
3748					}
3749					&SerializeWith(&self.r#typical_age_range)
3750				})?;
3751			} else {
3752				serialize_struct.skip_field("typicalAgeRange")?;
3753			}
3754			if !Vec::is_empty(&self.r#usage_info) {
3755				serialize_struct.serialize_field("usageInfo", {
3756					struct SerializeWith<'a>(&'a Vec<UsageInfoProperty>);
3757					impl<'a> Serialize for SerializeWith<'a> {
3758						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3759						where
3760							S: Serializer,
3761						{
3762							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3763								self.0, serializer,
3764							)
3765						}
3766					}
3767					&SerializeWith(&self.r#usage_info)
3768				})?;
3769			} else {
3770				serialize_struct.skip_field("usageInfo")?;
3771			}
3772			if !Vec::is_empty(&self.r#version) {
3773				serialize_struct.serialize_field("version", {
3774					struct SerializeWith<'a>(&'a Vec<VersionProperty>);
3775					impl<'a> Serialize for SerializeWith<'a> {
3776						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3777						where
3778							S: Serializer,
3779						{
3780							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3781								self.0, serializer,
3782							)
3783						}
3784					}
3785					&SerializeWith(&self.r#version)
3786				})?;
3787			} else {
3788				serialize_struct.skip_field("version")?;
3789			}
3790			if !Vec::is_empty(&self.r#video) {
3791				serialize_struct.serialize_field("video", {
3792					struct SerializeWith<'a>(&'a Vec<VideoProperty>);
3793					impl<'a> Serialize for SerializeWith<'a> {
3794						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3795						where
3796							S: Serializer,
3797						{
3798							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3799								self.0, serializer,
3800							)
3801						}
3802					}
3803					&SerializeWith(&self.r#video)
3804				})?;
3805			} else {
3806				serialize_struct.skip_field("video")?;
3807			}
3808			if !Vec::is_empty(&self.r#work_example) {
3809				serialize_struct.serialize_field("workExample", {
3810					struct SerializeWith<'a>(&'a Vec<WorkExampleProperty>);
3811					impl<'a> Serialize for SerializeWith<'a> {
3812						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3813						where
3814							S: Serializer,
3815						{
3816							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3817								self.0, serializer,
3818							)
3819						}
3820					}
3821					&SerializeWith(&self.r#work_example)
3822				})?;
3823			} else {
3824				serialize_struct.skip_field("workExample")?;
3825			}
3826			if !Vec::is_empty(&self.r#work_translation) {
3827				serialize_struct.serialize_field("workTranslation", {
3828					struct SerializeWith<'a>(&'a Vec<WorkTranslationProperty>);
3829					impl<'a> Serialize for SerializeWith<'a> {
3830						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3831						where
3832							S: Serializer,
3833						{
3834							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3835								self.0, serializer,
3836							)
3837						}
3838					}
3839					&SerializeWith(&self.r#work_translation)
3840				})?;
3841			} else {
3842				serialize_struct.skip_field("workTranslation")?;
3843			}
3844			if !Vec::is_empty(&self.r#character_attribute) {
3845				serialize_struct.serialize_field("characterAttribute", {
3846					struct SerializeWith<'a>(&'a Vec<CharacterAttributeProperty>);
3847					impl<'a> Serialize for SerializeWith<'a> {
3848						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3849						where
3850							S: Serializer,
3851						{
3852							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3853								self.0, serializer,
3854							)
3855						}
3856					}
3857					&SerializeWith(&self.r#character_attribute)
3858				})?;
3859			} else {
3860				serialize_struct.skip_field("characterAttribute")?;
3861			}
3862			if !Vec::is_empty(&self.r#game_item) {
3863				serialize_struct.serialize_field("gameItem", {
3864					struct SerializeWith<'a>(&'a Vec<GameItemProperty>);
3865					impl<'a> Serialize for SerializeWith<'a> {
3866						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3867						where
3868							S: Serializer,
3869						{
3870							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3871								self.0, serializer,
3872							)
3873						}
3874					}
3875					&SerializeWith(&self.r#game_item)
3876				})?;
3877			} else {
3878				serialize_struct.skip_field("gameItem")?;
3879			}
3880			if !Vec::is_empty(&self.r#game_location) {
3881				serialize_struct.serialize_field("gameLocation", {
3882					struct SerializeWith<'a>(&'a Vec<GameLocationProperty>);
3883					impl<'a> Serialize for SerializeWith<'a> {
3884						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3885						where
3886							S: Serializer,
3887						{
3888							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3889								self.0, serializer,
3890							)
3891						}
3892					}
3893					&SerializeWith(&self.r#game_location)
3894				})?;
3895			} else {
3896				serialize_struct.skip_field("gameLocation")?;
3897			}
3898			if !Vec::is_empty(&self.r#number_of_players) {
3899				serialize_struct.serialize_field("numberOfPlayers", {
3900					struct SerializeWith<'a>(&'a Vec<NumberOfPlayersProperty>);
3901					impl<'a> Serialize for SerializeWith<'a> {
3902						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3903						where
3904							S: Serializer,
3905						{
3906							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3907								self.0, serializer,
3908							)
3909						}
3910					}
3911					&SerializeWith(&self.r#number_of_players)
3912				})?;
3913			} else {
3914				serialize_struct.skip_field("numberOfPlayers")?;
3915			}
3916			if !Vec::is_empty(&self.r#quest) {
3917				serialize_struct.serialize_field("quest", {
3918					struct SerializeWith<'a>(&'a Vec<QuestProperty>);
3919					impl<'a> Serialize for SerializeWith<'a> {
3920						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3921						where
3922							S: Serializer,
3923						{
3924							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3925								self.0, serializer,
3926							)
3927						}
3928					}
3929					&SerializeWith(&self.r#quest)
3930				})?;
3931			} else {
3932				serialize_struct.skip_field("quest")?;
3933			}
3934			if !Vec::is_empty(&self.r#application_category) {
3935				serialize_struct.serialize_field("applicationCategory", {
3936					struct SerializeWith<'a>(&'a Vec<ApplicationCategoryProperty>);
3937					impl<'a> Serialize for SerializeWith<'a> {
3938						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3939						where
3940							S: Serializer,
3941						{
3942							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3943								self.0, serializer,
3944							)
3945						}
3946					}
3947					&SerializeWith(&self.r#application_category)
3948				})?;
3949			} else {
3950				serialize_struct.skip_field("applicationCategory")?;
3951			}
3952			if !Vec::is_empty(&self.r#application_sub_category) {
3953				serialize_struct.serialize_field("applicationSubCategory", {
3954					struct SerializeWith<'a>(&'a Vec<ApplicationSubCategoryProperty>);
3955					impl<'a> Serialize for SerializeWith<'a> {
3956						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3957						where
3958							S: Serializer,
3959						{
3960							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3961								self.0, serializer,
3962							)
3963						}
3964					}
3965					&SerializeWith(&self.r#application_sub_category)
3966				})?;
3967			} else {
3968				serialize_struct.skip_field("applicationSubCategory")?;
3969			}
3970			if !Vec::is_empty(&self.r#application_suite) {
3971				serialize_struct.serialize_field("applicationSuite", {
3972					struct SerializeWith<'a>(&'a Vec<ApplicationSuiteProperty>);
3973					impl<'a> Serialize for SerializeWith<'a> {
3974						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3975						where
3976							S: Serializer,
3977						{
3978							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3979								self.0, serializer,
3980							)
3981						}
3982					}
3983					&SerializeWith(&self.r#application_suite)
3984				})?;
3985			} else {
3986				serialize_struct.skip_field("applicationSuite")?;
3987			}
3988			if !Vec::is_empty(&self.r#available_on_device) {
3989				serialize_struct.serialize_field("availableOnDevice", {
3990					struct SerializeWith<'a>(&'a Vec<AvailableOnDeviceProperty>);
3991					impl<'a> Serialize for SerializeWith<'a> {
3992						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3993						where
3994							S: Serializer,
3995						{
3996							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3997								self.0, serializer,
3998							)
3999						}
4000					}
4001					&SerializeWith(&self.r#available_on_device)
4002				})?;
4003			} else {
4004				serialize_struct.skip_field("availableOnDevice")?;
4005			}
4006			if !Vec::is_empty(&self.r#countries_not_supported) {
4007				serialize_struct.serialize_field("countriesNotSupported", {
4008					struct SerializeWith<'a>(&'a Vec<CountriesNotSupportedProperty>);
4009					impl<'a> Serialize for SerializeWith<'a> {
4010						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4011						where
4012							S: Serializer,
4013						{
4014							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4015								self.0, serializer,
4016							)
4017						}
4018					}
4019					&SerializeWith(&self.r#countries_not_supported)
4020				})?;
4021			} else {
4022				serialize_struct.skip_field("countriesNotSupported")?;
4023			}
4024			if !Vec::is_empty(&self.r#countries_supported) {
4025				serialize_struct.serialize_field("countriesSupported", {
4026					struct SerializeWith<'a>(&'a Vec<CountriesSupportedProperty>);
4027					impl<'a> Serialize for SerializeWith<'a> {
4028						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4029						where
4030							S: Serializer,
4031						{
4032							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4033								self.0, serializer,
4034							)
4035						}
4036					}
4037					&SerializeWith(&self.r#countries_supported)
4038				})?;
4039			} else {
4040				serialize_struct.skip_field("countriesSupported")?;
4041			}
4042			if !Vec::is_empty(&self.r#device) {
4043				serialize_struct.serialize_field("device", {
4044					struct SerializeWith<'a>(&'a Vec<DeviceProperty>);
4045					impl<'a> Serialize for SerializeWith<'a> {
4046						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4047						where
4048							S: Serializer,
4049						{
4050							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4051								self.0, serializer,
4052							)
4053						}
4054					}
4055					&SerializeWith(&self.r#device)
4056				})?;
4057			} else {
4058				serialize_struct.skip_field("device")?;
4059			}
4060			if !Vec::is_empty(&self.r#download_url) {
4061				serialize_struct.serialize_field("downloadUrl", {
4062					struct SerializeWith<'a>(&'a Vec<DownloadUrlProperty>);
4063					impl<'a> Serialize for SerializeWith<'a> {
4064						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4065						where
4066							S: Serializer,
4067						{
4068							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4069								self.0, serializer,
4070							)
4071						}
4072					}
4073					&SerializeWith(&self.r#download_url)
4074				})?;
4075			} else {
4076				serialize_struct.skip_field("downloadUrl")?;
4077			}
4078			if !Vec::is_empty(&self.r#feature_list) {
4079				serialize_struct.serialize_field("featureList", {
4080					struct SerializeWith<'a>(&'a Vec<FeatureListProperty>);
4081					impl<'a> Serialize for SerializeWith<'a> {
4082						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4083						where
4084							S: Serializer,
4085						{
4086							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4087								self.0, serializer,
4088							)
4089						}
4090					}
4091					&SerializeWith(&self.r#feature_list)
4092				})?;
4093			} else {
4094				serialize_struct.skip_field("featureList")?;
4095			}
4096			if !Vec::is_empty(&self.r#file_size) {
4097				serialize_struct.serialize_field("fileSize", {
4098					struct SerializeWith<'a>(&'a Vec<FileSizeProperty>);
4099					impl<'a> Serialize for SerializeWith<'a> {
4100						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4101						where
4102							S: Serializer,
4103						{
4104							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4105								self.0, serializer,
4106							)
4107						}
4108					}
4109					&SerializeWith(&self.r#file_size)
4110				})?;
4111			} else {
4112				serialize_struct.skip_field("fileSize")?;
4113			}
4114			if !Vec::is_empty(&self.r#install_url) {
4115				serialize_struct.serialize_field("installUrl", {
4116					struct SerializeWith<'a>(&'a Vec<InstallUrlProperty>);
4117					impl<'a> Serialize for SerializeWith<'a> {
4118						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4119						where
4120							S: Serializer,
4121						{
4122							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4123								self.0, serializer,
4124							)
4125						}
4126					}
4127					&SerializeWith(&self.r#install_url)
4128				})?;
4129			} else {
4130				serialize_struct.skip_field("installUrl")?;
4131			}
4132			if !Vec::is_empty(&self.r#memory_requirements) {
4133				serialize_struct.serialize_field("memoryRequirements", {
4134					struct SerializeWith<'a>(&'a Vec<MemoryRequirementsProperty>);
4135					impl<'a> Serialize for SerializeWith<'a> {
4136						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4137						where
4138							S: Serializer,
4139						{
4140							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4141								self.0, serializer,
4142							)
4143						}
4144					}
4145					&SerializeWith(&self.r#memory_requirements)
4146				})?;
4147			} else {
4148				serialize_struct.skip_field("memoryRequirements")?;
4149			}
4150			if !Vec::is_empty(&self.r#operating_system) {
4151				serialize_struct.serialize_field("operatingSystem", {
4152					struct SerializeWith<'a>(&'a Vec<OperatingSystemProperty>);
4153					impl<'a> Serialize for SerializeWith<'a> {
4154						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4155						where
4156							S: Serializer,
4157						{
4158							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4159								self.0, serializer,
4160							)
4161						}
4162					}
4163					&SerializeWith(&self.r#operating_system)
4164				})?;
4165			} else {
4166				serialize_struct.skip_field("operatingSystem")?;
4167			}
4168			if !Vec::is_empty(&self.r#permissions) {
4169				serialize_struct.serialize_field("permissions", {
4170					struct SerializeWith<'a>(&'a Vec<PermissionsProperty>);
4171					impl<'a> Serialize for SerializeWith<'a> {
4172						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4173						where
4174							S: Serializer,
4175						{
4176							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4177								self.0, serializer,
4178							)
4179						}
4180					}
4181					&SerializeWith(&self.r#permissions)
4182				})?;
4183			} else {
4184				serialize_struct.skip_field("permissions")?;
4185			}
4186			if !Vec::is_empty(&self.r#processor_requirements) {
4187				serialize_struct.serialize_field("processorRequirements", {
4188					struct SerializeWith<'a>(&'a Vec<ProcessorRequirementsProperty>);
4189					impl<'a> Serialize for SerializeWith<'a> {
4190						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4191						where
4192							S: Serializer,
4193						{
4194							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4195								self.0, serializer,
4196							)
4197						}
4198					}
4199					&SerializeWith(&self.r#processor_requirements)
4200				})?;
4201			} else {
4202				serialize_struct.skip_field("processorRequirements")?;
4203			}
4204			if !Vec::is_empty(&self.r#release_notes) {
4205				serialize_struct.serialize_field("releaseNotes", {
4206					struct SerializeWith<'a>(&'a Vec<ReleaseNotesProperty>);
4207					impl<'a> Serialize for SerializeWith<'a> {
4208						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4209						where
4210							S: Serializer,
4211						{
4212							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4213								self.0, serializer,
4214							)
4215						}
4216					}
4217					&SerializeWith(&self.r#release_notes)
4218				})?;
4219			} else {
4220				serialize_struct.skip_field("releaseNotes")?;
4221			}
4222			if !Vec::is_empty(&self.r#requirements) {
4223				serialize_struct.serialize_field("requirements", {
4224					struct SerializeWith<'a>(&'a Vec<RequirementsProperty>);
4225					impl<'a> Serialize for SerializeWith<'a> {
4226						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4227						where
4228							S: Serializer,
4229						{
4230							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4231								self.0, serializer,
4232							)
4233						}
4234					}
4235					&SerializeWith(&self.r#requirements)
4236				})?;
4237			} else {
4238				serialize_struct.skip_field("requirements")?;
4239			}
4240			if !Vec::is_empty(&self.r#screenshot) {
4241				serialize_struct.serialize_field("screenshot", {
4242					struct SerializeWith<'a>(&'a Vec<ScreenshotProperty>);
4243					impl<'a> Serialize for SerializeWith<'a> {
4244						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4245						where
4246							S: Serializer,
4247						{
4248							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4249								self.0, serializer,
4250							)
4251						}
4252					}
4253					&SerializeWith(&self.r#screenshot)
4254				})?;
4255			} else {
4256				serialize_struct.skip_field("screenshot")?;
4257			}
4258			if !Vec::is_empty(&self.r#software_add_on) {
4259				serialize_struct.serialize_field("softwareAddOn", {
4260					struct SerializeWith<'a>(&'a Vec<SoftwareAddOnProperty>);
4261					impl<'a> Serialize for SerializeWith<'a> {
4262						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4263						where
4264							S: Serializer,
4265						{
4266							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4267								self.0, serializer,
4268							)
4269						}
4270					}
4271					&SerializeWith(&self.r#software_add_on)
4272				})?;
4273			} else {
4274				serialize_struct.skip_field("softwareAddOn")?;
4275			}
4276			if !Vec::is_empty(&self.r#software_help) {
4277				serialize_struct.serialize_field("softwareHelp", {
4278					struct SerializeWith<'a>(&'a Vec<SoftwareHelpProperty>);
4279					impl<'a> Serialize for SerializeWith<'a> {
4280						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4281						where
4282							S: Serializer,
4283						{
4284							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4285								self.0, serializer,
4286							)
4287						}
4288					}
4289					&SerializeWith(&self.r#software_help)
4290				})?;
4291			} else {
4292				serialize_struct.skip_field("softwareHelp")?;
4293			}
4294			if !Vec::is_empty(&self.r#software_requirements) {
4295				serialize_struct.serialize_field("softwareRequirements", {
4296					struct SerializeWith<'a>(&'a Vec<SoftwareRequirementsProperty>);
4297					impl<'a> Serialize for SerializeWith<'a> {
4298						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4299						where
4300							S: Serializer,
4301						{
4302							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4303								self.0, serializer,
4304							)
4305						}
4306					}
4307					&SerializeWith(&self.r#software_requirements)
4308				})?;
4309			} else {
4310				serialize_struct.skip_field("softwareRequirements")?;
4311			}
4312			if !Vec::is_empty(&self.r#software_version) {
4313				serialize_struct.serialize_field("softwareVersion", {
4314					struct SerializeWith<'a>(&'a Vec<SoftwareVersionProperty>);
4315					impl<'a> Serialize for SerializeWith<'a> {
4316						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4317						where
4318							S: Serializer,
4319						{
4320							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4321								self.0, serializer,
4322							)
4323						}
4324					}
4325					&SerializeWith(&self.r#software_version)
4326				})?;
4327			} else {
4328				serialize_struct.skip_field("softwareVersion")?;
4329			}
4330			if !Vec::is_empty(&self.r#storage_requirements) {
4331				serialize_struct.serialize_field("storageRequirements", {
4332					struct SerializeWith<'a>(&'a Vec<StorageRequirementsProperty>);
4333					impl<'a> Serialize for SerializeWith<'a> {
4334						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4335						where
4336							S: Serializer,
4337						{
4338							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4339								self.0, serializer,
4340							)
4341						}
4342					}
4343					&SerializeWith(&self.r#storage_requirements)
4344				})?;
4345			} else {
4346				serialize_struct.skip_field("storageRequirements")?;
4347			}
4348			if !Vec::is_empty(&self.r#supporting_data) {
4349				serialize_struct.serialize_field("supportingData", {
4350					struct SerializeWith<'a>(&'a Vec<SupportingDataProperty>);
4351					impl<'a> Serialize for SerializeWith<'a> {
4352						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4353						where
4354							S: Serializer,
4355						{
4356							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4357								self.0, serializer,
4358							)
4359						}
4360					}
4361					&SerializeWith(&self.r#supporting_data)
4362				})?;
4363			} else {
4364				serialize_struct.skip_field("supportingData")?;
4365			}
4366			if !Vec::is_empty(&self.r#additional_type) {
4367				serialize_struct.serialize_field("additionalType", {
4368					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
4369					impl<'a> Serialize for SerializeWith<'a> {
4370						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4371						where
4372							S: Serializer,
4373						{
4374							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4375								self.0, serializer,
4376							)
4377						}
4378					}
4379					&SerializeWith(&self.r#additional_type)
4380				})?;
4381			} else {
4382				serialize_struct.skip_field("additionalType")?;
4383			}
4384			if !Vec::is_empty(&self.r#alternate_name) {
4385				serialize_struct.serialize_field("alternateName", {
4386					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
4387					impl<'a> Serialize for SerializeWith<'a> {
4388						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4389						where
4390							S: Serializer,
4391						{
4392							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4393								self.0, serializer,
4394							)
4395						}
4396					}
4397					&SerializeWith(&self.r#alternate_name)
4398				})?;
4399			} else {
4400				serialize_struct.skip_field("alternateName")?;
4401			}
4402			if !Vec::is_empty(&self.r#description) {
4403				serialize_struct.serialize_field("description", {
4404					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
4405					impl<'a> Serialize for SerializeWith<'a> {
4406						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4407						where
4408							S: Serializer,
4409						{
4410							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4411								self.0, serializer,
4412							)
4413						}
4414					}
4415					&SerializeWith(&self.r#description)
4416				})?;
4417			} else {
4418				serialize_struct.skip_field("description")?;
4419			}
4420			if !Vec::is_empty(&self.r#disambiguating_description) {
4421				serialize_struct.serialize_field("disambiguatingDescription", {
4422					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
4423					impl<'a> Serialize for SerializeWith<'a> {
4424						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4425						where
4426							S: Serializer,
4427						{
4428							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4429								self.0, serializer,
4430							)
4431						}
4432					}
4433					&SerializeWith(&self.r#disambiguating_description)
4434				})?;
4435			} else {
4436				serialize_struct.skip_field("disambiguatingDescription")?;
4437			}
4438			if !Vec::is_empty(&self.r#identifier) {
4439				serialize_struct.serialize_field("identifier", {
4440					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
4441					impl<'a> Serialize for SerializeWith<'a> {
4442						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4443						where
4444							S: Serializer,
4445						{
4446							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4447								self.0, serializer,
4448							)
4449						}
4450					}
4451					&SerializeWith(&self.r#identifier)
4452				})?;
4453			} else {
4454				serialize_struct.skip_field("identifier")?;
4455			}
4456			if !Vec::is_empty(&self.r#image) {
4457				serialize_struct.serialize_field("image", {
4458					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
4459					impl<'a> Serialize for SerializeWith<'a> {
4460						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4461						where
4462							S: Serializer,
4463						{
4464							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4465								self.0, serializer,
4466							)
4467						}
4468					}
4469					&SerializeWith(&self.r#image)
4470				})?;
4471			} else {
4472				serialize_struct.skip_field("image")?;
4473			}
4474			if !Vec::is_empty(&self.r#main_entity_of_page) {
4475				serialize_struct.serialize_field("mainEntityOfPage", {
4476					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
4477					impl<'a> Serialize for SerializeWith<'a> {
4478						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4479						where
4480							S: Serializer,
4481						{
4482							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4483								self.0, serializer,
4484							)
4485						}
4486					}
4487					&SerializeWith(&self.r#main_entity_of_page)
4488				})?;
4489			} else {
4490				serialize_struct.skip_field("mainEntityOfPage")?;
4491			}
4492			if !Vec::is_empty(&self.r#name) {
4493				serialize_struct.serialize_field("name", {
4494					struct SerializeWith<'a>(&'a Vec<NameProperty>);
4495					impl<'a> Serialize for SerializeWith<'a> {
4496						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4497						where
4498							S: Serializer,
4499						{
4500							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4501								self.0, serializer,
4502							)
4503						}
4504					}
4505					&SerializeWith(&self.r#name)
4506				})?;
4507			} else {
4508				serialize_struct.skip_field("name")?;
4509			}
4510			if !Vec::is_empty(&self.r#potential_action) {
4511				serialize_struct.serialize_field("potentialAction", {
4512					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
4513					impl<'a> Serialize for SerializeWith<'a> {
4514						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4515						where
4516							S: Serializer,
4517						{
4518							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4519								self.0, serializer,
4520							)
4521						}
4522					}
4523					&SerializeWith(&self.r#potential_action)
4524				})?;
4525			} else {
4526				serialize_struct.skip_field("potentialAction")?;
4527			}
4528			if !Vec::is_empty(&self.r#same_as) {
4529				serialize_struct.serialize_field("sameAs", {
4530					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
4531					impl<'a> Serialize for SerializeWith<'a> {
4532						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4533						where
4534							S: Serializer,
4535						{
4536							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4537								self.0, serializer,
4538							)
4539						}
4540					}
4541					&SerializeWith(&self.r#same_as)
4542				})?;
4543			} else {
4544				serialize_struct.skip_field("sameAs")?;
4545			}
4546			if !Vec::is_empty(&self.r#subject_of) {
4547				serialize_struct.serialize_field("subjectOf", {
4548					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
4549					impl<'a> Serialize for SerializeWith<'a> {
4550						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4551						where
4552							S: Serializer,
4553						{
4554							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4555								self.0, serializer,
4556							)
4557						}
4558					}
4559					&SerializeWith(&self.r#subject_of)
4560				})?;
4561			} else {
4562				serialize_struct.skip_field("subjectOf")?;
4563			}
4564			if !Vec::is_empty(&self.r#url) {
4565				serialize_struct.serialize_field("url", {
4566					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
4567					impl<'a> Serialize for SerializeWith<'a> {
4568						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4569						where
4570							S: Serializer,
4571						{
4572							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
4573								self.0, serializer,
4574							)
4575						}
4576					}
4577					&SerializeWith(&self.r#url)
4578				})?;
4579			} else {
4580				serialize_struct.skip_field("url")?;
4581			}
4582			serialize_struct.end()
4583		}
4584	}
4585	impl<'de> Deserialize<'de> for VideoGame {
4586		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4587		where
4588			D: Deserializer<'de>,
4589		{
4590			enum Field {
4591				Actor,
4592				Actors,
4593				CheatCode,
4594				Director,
4595				Directors,
4596				GameEdition,
4597				GamePlatform,
4598				GameServer,
4599				GameTip,
4600				MusicBy,
4601				PlayMode,
4602				Trailer,
4603				About,
4604				Abstract,
4605				AccessMode,
4606				AccessModeSufficient,
4607				AccessibilityApi,
4608				AccessibilityControl,
4609				AccessibilityFeature,
4610				AccessibilityHazard,
4611				AccessibilitySummary,
4612				AccountablePerson,
4613				AcquireLicensePage,
4614				AggregateRating,
4615				AlternativeHeadline,
4616				ArchivedAt,
4617				Assesses,
4618				AssociatedMedia,
4619				Audience,
4620				Audio,
4621				Author,
4622				Award,
4623				Awards,
4624				Character,
4625				Citation,
4626				Comment,
4627				CommentCount,
4628				ConditionsOfAccess,
4629				ContentLocation,
4630				ContentRating,
4631				ContentReferenceTime,
4632				Contributor,
4633				CopyrightHolder,
4634				CopyrightNotice,
4635				CopyrightYear,
4636				Correction,
4637				CountryOfOrigin,
4638				CreativeWorkStatus,
4639				Creator,
4640				CreditText,
4641				DateCreated,
4642				DateModified,
4643				DatePublished,
4644				DiscussionUrl,
4645				EditEidr,
4646				Editor,
4647				EducationalAlignment,
4648				EducationalLevel,
4649				EducationalUse,
4650				Encoding,
4651				EncodingFormat,
4652				Encodings,
4653				ExampleOfWork,
4654				Expires,
4655				FileFormat,
4656				Funder,
4657				Funding,
4658				Genre,
4659				HasPart,
4660				Headline,
4661				InLanguage,
4662				InteractionStatistic,
4663				InteractivityType,
4664				InterpretedAsClaim,
4665				IsAccessibleForFree,
4666				IsBasedOn,
4667				IsBasedOnUrl,
4668				IsFamilyFriendly,
4669				IsPartOf,
4670				Keywords,
4671				LearningResourceType,
4672				License,
4673				LocationCreated,
4674				MainEntity,
4675				Maintainer,
4676				Material,
4677				MaterialExtent,
4678				Mentions,
4679				Offers,
4680				Pattern,
4681				Position,
4682				Producer,
4683				Provider,
4684				Publication,
4685				Publisher,
4686				PublisherImprint,
4687				PublishingPrinciples,
4688				RecordedAt,
4689				ReleasedEvent,
4690				Review,
4691				Reviews,
4692				SchemaVersion,
4693				SdDatePublished,
4694				SdLicense,
4695				SdPublisher,
4696				Size,
4697				SourceOrganization,
4698				Spatial,
4699				SpatialCoverage,
4700				Sponsor,
4701				Teaches,
4702				Temporal,
4703				TemporalCoverage,
4704				Text,
4705				Thumbnail,
4706				ThumbnailUrl,
4707				TimeRequired,
4708				TranslationOfWork,
4709				Translator,
4710				TypicalAgeRange,
4711				UsageInfo,
4712				Version,
4713				Video,
4714				WorkExample,
4715				WorkTranslation,
4716				CharacterAttribute,
4717				GameItem,
4718				GameLocation,
4719				NumberOfPlayers,
4720				Quest,
4721				ApplicationCategory,
4722				ApplicationSubCategory,
4723				ApplicationSuite,
4724				AvailableOnDevice,
4725				CountriesNotSupported,
4726				CountriesSupported,
4727				Device,
4728				DownloadUrl,
4729				FeatureList,
4730				FileSize,
4731				InstallUrl,
4732				MemoryRequirements,
4733				OperatingSystem,
4734				Permissions,
4735				ProcessorRequirements,
4736				ReleaseNotes,
4737				Requirements,
4738				Screenshot,
4739				SoftwareAddOn,
4740				SoftwareHelp,
4741				SoftwareRequirements,
4742				SoftwareVersion,
4743				StorageRequirements,
4744				SupportingData,
4745				AdditionalType,
4746				AlternateName,
4747				Description,
4748				DisambiguatingDescription,
4749				Identifier,
4750				Image,
4751				MainEntityOfPage,
4752				Name,
4753				PotentialAction,
4754				SameAs,
4755				SubjectOf,
4756				Url,
4757				Ignore,
4758			}
4759			struct FieldVisitor;
4760			impl<'de> Visitor<'de> for FieldVisitor {
4761				type Value = Field;
4762				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
4763					formatter.write_str("field identifier")
4764				}
4765				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
4766				where
4767					E: de::Error,
4768				{
4769					match value {
4770						"actor" => Ok(Field::Actor),
4771						"actors" => Ok(Field::Actors),
4772						"cheatCode" => Ok(Field::CheatCode),
4773						"director" => Ok(Field::Director),
4774						"directors" => Ok(Field::Directors),
4775						"gameEdition" => Ok(Field::GameEdition),
4776						"gamePlatform" => Ok(Field::GamePlatform),
4777						"gameServer" => Ok(Field::GameServer),
4778						"gameTip" => Ok(Field::GameTip),
4779						"musicBy" => Ok(Field::MusicBy),
4780						"playMode" => Ok(Field::PlayMode),
4781						"trailer" => Ok(Field::Trailer),
4782						"about" => Ok(Field::About),
4783						"abstract" => Ok(Field::Abstract),
4784						"accessMode" => Ok(Field::AccessMode),
4785						"accessModeSufficient" => Ok(Field::AccessModeSufficient),
4786						"accessibilityAPI" => Ok(Field::AccessibilityApi),
4787						"accessibilityControl" => Ok(Field::AccessibilityControl),
4788						"accessibilityFeature" => Ok(Field::AccessibilityFeature),
4789						"accessibilityHazard" => Ok(Field::AccessibilityHazard),
4790						"accessibilitySummary" => Ok(Field::AccessibilitySummary),
4791						"accountablePerson" => Ok(Field::AccountablePerson),
4792						"acquireLicensePage" => Ok(Field::AcquireLicensePage),
4793						"aggregateRating" => Ok(Field::AggregateRating),
4794						"alternativeHeadline" => Ok(Field::AlternativeHeadline),
4795						"archivedAt" => Ok(Field::ArchivedAt),
4796						"assesses" => Ok(Field::Assesses),
4797						"associatedMedia" => Ok(Field::AssociatedMedia),
4798						"audience" => Ok(Field::Audience),
4799						"audio" => Ok(Field::Audio),
4800						"author" => Ok(Field::Author),
4801						"award" => Ok(Field::Award),
4802						"awards" => Ok(Field::Awards),
4803						"character" => Ok(Field::Character),
4804						"citation" => Ok(Field::Citation),
4805						"comment" => Ok(Field::Comment),
4806						"commentCount" => Ok(Field::CommentCount),
4807						"conditionsOfAccess" => Ok(Field::ConditionsOfAccess),
4808						"contentLocation" => Ok(Field::ContentLocation),
4809						"contentRating" => Ok(Field::ContentRating),
4810						"contentReferenceTime" => Ok(Field::ContentReferenceTime),
4811						"contributor" => Ok(Field::Contributor),
4812						"copyrightHolder" => Ok(Field::CopyrightHolder),
4813						"copyrightNotice" => Ok(Field::CopyrightNotice),
4814						"copyrightYear" => Ok(Field::CopyrightYear),
4815						"correction" => Ok(Field::Correction),
4816						"countryOfOrigin" => Ok(Field::CountryOfOrigin),
4817						"creativeWorkStatus" => Ok(Field::CreativeWorkStatus),
4818						"creator" => Ok(Field::Creator),
4819						"creditText" => Ok(Field::CreditText),
4820						"dateCreated" => Ok(Field::DateCreated),
4821						"dateModified" => Ok(Field::DateModified),
4822						"datePublished" => Ok(Field::DatePublished),
4823						"discussionUrl" => Ok(Field::DiscussionUrl),
4824						"editEIDR" => Ok(Field::EditEidr),
4825						"editor" => Ok(Field::Editor),
4826						"educationalAlignment" => Ok(Field::EducationalAlignment),
4827						"educationalLevel" => Ok(Field::EducationalLevel),
4828						"educationalUse" => Ok(Field::EducationalUse),
4829						"encoding" => Ok(Field::Encoding),
4830						"encodingFormat" => Ok(Field::EncodingFormat),
4831						"encodings" => Ok(Field::Encodings),
4832						"exampleOfWork" => Ok(Field::ExampleOfWork),
4833						"expires" => Ok(Field::Expires),
4834						"fileFormat" => Ok(Field::FileFormat),
4835						"funder" => Ok(Field::Funder),
4836						"funding" => Ok(Field::Funding),
4837						"genre" => Ok(Field::Genre),
4838						"hasPart" => Ok(Field::HasPart),
4839						"headline" => Ok(Field::Headline),
4840						"inLanguage" => Ok(Field::InLanguage),
4841						"interactionStatistic" => Ok(Field::InteractionStatistic),
4842						"interactivityType" => Ok(Field::InteractivityType),
4843						"interpretedAsClaim" => Ok(Field::InterpretedAsClaim),
4844						"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
4845						"isBasedOn" => Ok(Field::IsBasedOn),
4846						"isBasedOnUrl" => Ok(Field::IsBasedOnUrl),
4847						"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
4848						"isPartOf" => Ok(Field::IsPartOf),
4849						"keywords" => Ok(Field::Keywords),
4850						"learningResourceType" => Ok(Field::LearningResourceType),
4851						"license" => Ok(Field::License),
4852						"locationCreated" => Ok(Field::LocationCreated),
4853						"mainEntity" => Ok(Field::MainEntity),
4854						"maintainer" => Ok(Field::Maintainer),
4855						"material" => Ok(Field::Material),
4856						"materialExtent" => Ok(Field::MaterialExtent),
4857						"mentions" => Ok(Field::Mentions),
4858						"offers" => Ok(Field::Offers),
4859						"pattern" => Ok(Field::Pattern),
4860						"position" => Ok(Field::Position),
4861						"producer" => Ok(Field::Producer),
4862						"provider" => Ok(Field::Provider),
4863						"publication" => Ok(Field::Publication),
4864						"publisher" => Ok(Field::Publisher),
4865						"publisherImprint" => Ok(Field::PublisherImprint),
4866						"publishingPrinciples" => Ok(Field::PublishingPrinciples),
4867						"recordedAt" => Ok(Field::RecordedAt),
4868						"releasedEvent" => Ok(Field::ReleasedEvent),
4869						"review" => Ok(Field::Review),
4870						"reviews" => Ok(Field::Reviews),
4871						"schemaVersion" => Ok(Field::SchemaVersion),
4872						"sdDatePublished" => Ok(Field::SdDatePublished),
4873						"sdLicense" => Ok(Field::SdLicense),
4874						"sdPublisher" => Ok(Field::SdPublisher),
4875						"size" => Ok(Field::Size),
4876						"sourceOrganization" => Ok(Field::SourceOrganization),
4877						"spatial" => Ok(Field::Spatial),
4878						"spatialCoverage" => Ok(Field::SpatialCoverage),
4879						"sponsor" => Ok(Field::Sponsor),
4880						"teaches" => Ok(Field::Teaches),
4881						"temporal" => Ok(Field::Temporal),
4882						"temporalCoverage" => Ok(Field::TemporalCoverage),
4883						"text" => Ok(Field::Text),
4884						"thumbnail" => Ok(Field::Thumbnail),
4885						"thumbnailUrl" => Ok(Field::ThumbnailUrl),
4886						"timeRequired" => Ok(Field::TimeRequired),
4887						"translationOfWork" => Ok(Field::TranslationOfWork),
4888						"translator" => Ok(Field::Translator),
4889						"typicalAgeRange" => Ok(Field::TypicalAgeRange),
4890						"usageInfo" => Ok(Field::UsageInfo),
4891						"version" => Ok(Field::Version),
4892						"video" => Ok(Field::Video),
4893						"workExample" => Ok(Field::WorkExample),
4894						"workTranslation" => Ok(Field::WorkTranslation),
4895						"characterAttribute" => Ok(Field::CharacterAttribute),
4896						"gameItem" => Ok(Field::GameItem),
4897						"gameLocation" => Ok(Field::GameLocation),
4898						"numberOfPlayers" => Ok(Field::NumberOfPlayers),
4899						"quest" => Ok(Field::Quest),
4900						"applicationCategory" => Ok(Field::ApplicationCategory),
4901						"applicationSubCategory" => Ok(Field::ApplicationSubCategory),
4902						"applicationSuite" => Ok(Field::ApplicationSuite),
4903						"availableOnDevice" => Ok(Field::AvailableOnDevice),
4904						"countriesNotSupported" => Ok(Field::CountriesNotSupported),
4905						"countriesSupported" => Ok(Field::CountriesSupported),
4906						"device" => Ok(Field::Device),
4907						"downloadUrl" => Ok(Field::DownloadUrl),
4908						"featureList" => Ok(Field::FeatureList),
4909						"fileSize" => Ok(Field::FileSize),
4910						"installUrl" => Ok(Field::InstallUrl),
4911						"memoryRequirements" => Ok(Field::MemoryRequirements),
4912						"operatingSystem" => Ok(Field::OperatingSystem),
4913						"permissions" => Ok(Field::Permissions),
4914						"processorRequirements" => Ok(Field::ProcessorRequirements),
4915						"releaseNotes" => Ok(Field::ReleaseNotes),
4916						"requirements" => Ok(Field::Requirements),
4917						"screenshot" => Ok(Field::Screenshot),
4918						"softwareAddOn" => Ok(Field::SoftwareAddOn),
4919						"softwareHelp" => Ok(Field::SoftwareHelp),
4920						"softwareRequirements" => Ok(Field::SoftwareRequirements),
4921						"softwareVersion" => Ok(Field::SoftwareVersion),
4922						"storageRequirements" => Ok(Field::StorageRequirements),
4923						"supportingData" => Ok(Field::SupportingData),
4924						"additionalType" => Ok(Field::AdditionalType),
4925						"alternateName" => Ok(Field::AlternateName),
4926						"description" => Ok(Field::Description),
4927						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
4928						"identifier" => Ok(Field::Identifier),
4929						"image" => Ok(Field::Image),
4930						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
4931						"name" => Ok(Field::Name),
4932						"potentialAction" => Ok(Field::PotentialAction),
4933						"sameAs" => Ok(Field::SameAs),
4934						"subjectOf" => Ok(Field::SubjectOf),
4935						"url" => Ok(Field::Url),
4936						"id" | "type" => Ok(Field::Ignore),
4937						_ => Err(de::Error::unknown_field(value, FIELDS)),
4938					}
4939				}
4940				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
4941				where
4942					E: de::Error,
4943				{
4944					match value {
4945						b"actor" => Ok(Field::Actor),
4946						b"actors" => Ok(Field::Actors),
4947						b"cheatCode" => Ok(Field::CheatCode),
4948						b"director" => Ok(Field::Director),
4949						b"directors" => Ok(Field::Directors),
4950						b"gameEdition" => Ok(Field::GameEdition),
4951						b"gamePlatform" => Ok(Field::GamePlatform),
4952						b"gameServer" => Ok(Field::GameServer),
4953						b"gameTip" => Ok(Field::GameTip),
4954						b"musicBy" => Ok(Field::MusicBy),
4955						b"playMode" => Ok(Field::PlayMode),
4956						b"trailer" => Ok(Field::Trailer),
4957						b"about" => Ok(Field::About),
4958						b"abstract" => Ok(Field::Abstract),
4959						b"accessMode" => Ok(Field::AccessMode),
4960						b"accessModeSufficient" => Ok(Field::AccessModeSufficient),
4961						b"accessibilityAPI" => Ok(Field::AccessibilityApi),
4962						b"accessibilityControl" => Ok(Field::AccessibilityControl),
4963						b"accessibilityFeature" => Ok(Field::AccessibilityFeature),
4964						b"accessibilityHazard" => Ok(Field::AccessibilityHazard),
4965						b"accessibilitySummary" => Ok(Field::AccessibilitySummary),
4966						b"accountablePerson" => Ok(Field::AccountablePerson),
4967						b"acquireLicensePage" => Ok(Field::AcquireLicensePage),
4968						b"aggregateRating" => Ok(Field::AggregateRating),
4969						b"alternativeHeadline" => Ok(Field::AlternativeHeadline),
4970						b"archivedAt" => Ok(Field::ArchivedAt),
4971						b"assesses" => Ok(Field::Assesses),
4972						b"associatedMedia" => Ok(Field::AssociatedMedia),
4973						b"audience" => Ok(Field::Audience),
4974						b"audio" => Ok(Field::Audio),
4975						b"author" => Ok(Field::Author),
4976						b"award" => Ok(Field::Award),
4977						b"awards" => Ok(Field::Awards),
4978						b"character" => Ok(Field::Character),
4979						b"citation" => Ok(Field::Citation),
4980						b"comment" => Ok(Field::Comment),
4981						b"commentCount" => Ok(Field::CommentCount),
4982						b"conditionsOfAccess" => Ok(Field::ConditionsOfAccess),
4983						b"contentLocation" => Ok(Field::ContentLocation),
4984						b"contentRating" => Ok(Field::ContentRating),
4985						b"contentReferenceTime" => Ok(Field::ContentReferenceTime),
4986						b"contributor" => Ok(Field::Contributor),
4987						b"copyrightHolder" => Ok(Field::CopyrightHolder),
4988						b"copyrightNotice" => Ok(Field::CopyrightNotice),
4989						b"copyrightYear" => Ok(Field::CopyrightYear),
4990						b"correction" => Ok(Field::Correction),
4991						b"countryOfOrigin" => Ok(Field::CountryOfOrigin),
4992						b"creativeWorkStatus" => Ok(Field::CreativeWorkStatus),
4993						b"creator" => Ok(Field::Creator),
4994						b"creditText" => Ok(Field::CreditText),
4995						b"dateCreated" => Ok(Field::DateCreated),
4996						b"dateModified" => Ok(Field::DateModified),
4997						b"datePublished" => Ok(Field::DatePublished),
4998						b"discussionUrl" => Ok(Field::DiscussionUrl),
4999						b"editEIDR" => Ok(Field::EditEidr),
5000						b"editor" => Ok(Field::Editor),
5001						b"educationalAlignment" => Ok(Field::EducationalAlignment),
5002						b"educationalLevel" => Ok(Field::EducationalLevel),
5003						b"educationalUse" => Ok(Field::EducationalUse),
5004						b"encoding" => Ok(Field::Encoding),
5005						b"encodingFormat" => Ok(Field::EncodingFormat),
5006						b"encodings" => Ok(Field::Encodings),
5007						b"exampleOfWork" => Ok(Field::ExampleOfWork),
5008						b"expires" => Ok(Field::Expires),
5009						b"fileFormat" => Ok(Field::FileFormat),
5010						b"funder" => Ok(Field::Funder),
5011						b"funding" => Ok(Field::Funding),
5012						b"genre" => Ok(Field::Genre),
5013						b"hasPart" => Ok(Field::HasPart),
5014						b"headline" => Ok(Field::Headline),
5015						b"inLanguage" => Ok(Field::InLanguage),
5016						b"interactionStatistic" => Ok(Field::InteractionStatistic),
5017						b"interactivityType" => Ok(Field::InteractivityType),
5018						b"interpretedAsClaim" => Ok(Field::InterpretedAsClaim),
5019						b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
5020						b"isBasedOn" => Ok(Field::IsBasedOn),
5021						b"isBasedOnUrl" => Ok(Field::IsBasedOnUrl),
5022						b"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
5023						b"isPartOf" => Ok(Field::IsPartOf),
5024						b"keywords" => Ok(Field::Keywords),
5025						b"learningResourceType" => Ok(Field::LearningResourceType),
5026						b"license" => Ok(Field::License),
5027						b"locationCreated" => Ok(Field::LocationCreated),
5028						b"mainEntity" => Ok(Field::MainEntity),
5029						b"maintainer" => Ok(Field::Maintainer),
5030						b"material" => Ok(Field::Material),
5031						b"materialExtent" => Ok(Field::MaterialExtent),
5032						b"mentions" => Ok(Field::Mentions),
5033						b"offers" => Ok(Field::Offers),
5034						b"pattern" => Ok(Field::Pattern),
5035						b"position" => Ok(Field::Position),
5036						b"producer" => Ok(Field::Producer),
5037						b"provider" => Ok(Field::Provider),
5038						b"publication" => Ok(Field::Publication),
5039						b"publisher" => Ok(Field::Publisher),
5040						b"publisherImprint" => Ok(Field::PublisherImprint),
5041						b"publishingPrinciples" => Ok(Field::PublishingPrinciples),
5042						b"recordedAt" => Ok(Field::RecordedAt),
5043						b"releasedEvent" => Ok(Field::ReleasedEvent),
5044						b"review" => Ok(Field::Review),
5045						b"reviews" => Ok(Field::Reviews),
5046						b"schemaVersion" => Ok(Field::SchemaVersion),
5047						b"sdDatePublished" => Ok(Field::SdDatePublished),
5048						b"sdLicense" => Ok(Field::SdLicense),
5049						b"sdPublisher" => Ok(Field::SdPublisher),
5050						b"size" => Ok(Field::Size),
5051						b"sourceOrganization" => Ok(Field::SourceOrganization),
5052						b"spatial" => Ok(Field::Spatial),
5053						b"spatialCoverage" => Ok(Field::SpatialCoverage),
5054						b"sponsor" => Ok(Field::Sponsor),
5055						b"teaches" => Ok(Field::Teaches),
5056						b"temporal" => Ok(Field::Temporal),
5057						b"temporalCoverage" => Ok(Field::TemporalCoverage),
5058						b"text" => Ok(Field::Text),
5059						b"thumbnail" => Ok(Field::Thumbnail),
5060						b"thumbnailUrl" => Ok(Field::ThumbnailUrl),
5061						b"timeRequired" => Ok(Field::TimeRequired),
5062						b"translationOfWork" => Ok(Field::TranslationOfWork),
5063						b"translator" => Ok(Field::Translator),
5064						b"typicalAgeRange" => Ok(Field::TypicalAgeRange),
5065						b"usageInfo" => Ok(Field::UsageInfo),
5066						b"version" => Ok(Field::Version),
5067						b"video" => Ok(Field::Video),
5068						b"workExample" => Ok(Field::WorkExample),
5069						b"workTranslation" => Ok(Field::WorkTranslation),
5070						b"characterAttribute" => Ok(Field::CharacterAttribute),
5071						b"gameItem" => Ok(Field::GameItem),
5072						b"gameLocation" => Ok(Field::GameLocation),
5073						b"numberOfPlayers" => Ok(Field::NumberOfPlayers),
5074						b"quest" => Ok(Field::Quest),
5075						b"applicationCategory" => Ok(Field::ApplicationCategory),
5076						b"applicationSubCategory" => Ok(Field::ApplicationSubCategory),
5077						b"applicationSuite" => Ok(Field::ApplicationSuite),
5078						b"availableOnDevice" => Ok(Field::AvailableOnDevice),
5079						b"countriesNotSupported" => Ok(Field::CountriesNotSupported),
5080						b"countriesSupported" => Ok(Field::CountriesSupported),
5081						b"device" => Ok(Field::Device),
5082						b"downloadUrl" => Ok(Field::DownloadUrl),
5083						b"featureList" => Ok(Field::FeatureList),
5084						b"fileSize" => Ok(Field::FileSize),
5085						b"installUrl" => Ok(Field::InstallUrl),
5086						b"memoryRequirements" => Ok(Field::MemoryRequirements),
5087						b"operatingSystem" => Ok(Field::OperatingSystem),
5088						b"permissions" => Ok(Field::Permissions),
5089						b"processorRequirements" => Ok(Field::ProcessorRequirements),
5090						b"releaseNotes" => Ok(Field::ReleaseNotes),
5091						b"requirements" => Ok(Field::Requirements),
5092						b"screenshot" => Ok(Field::Screenshot),
5093						b"softwareAddOn" => Ok(Field::SoftwareAddOn),
5094						b"softwareHelp" => Ok(Field::SoftwareHelp),
5095						b"softwareRequirements" => Ok(Field::SoftwareRequirements),
5096						b"softwareVersion" => Ok(Field::SoftwareVersion),
5097						b"storageRequirements" => Ok(Field::StorageRequirements),
5098						b"supportingData" => Ok(Field::SupportingData),
5099						b"additionalType" => Ok(Field::AdditionalType),
5100						b"alternateName" => Ok(Field::AlternateName),
5101						b"description" => Ok(Field::Description),
5102						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
5103						b"identifier" => Ok(Field::Identifier),
5104						b"image" => Ok(Field::Image),
5105						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
5106						b"name" => Ok(Field::Name),
5107						b"potentialAction" => Ok(Field::PotentialAction),
5108						b"sameAs" => Ok(Field::SameAs),
5109						b"subjectOf" => Ok(Field::SubjectOf),
5110						b"url" => Ok(Field::Url),
5111						b"id" | b"type" => Ok(Field::Ignore),
5112						_ => {
5113							let value = &String::from_utf8_lossy(value);
5114							Err(de::Error::unknown_field(value, FIELDS))
5115						}
5116					}
5117				}
5118			}
5119			impl<'de> Deserialize<'de> for Field {
5120				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5121				where
5122					D: Deserializer<'de>,
5123				{
5124					deserializer.deserialize_identifier(FieldVisitor)
5125				}
5126			}
5127			struct ClassVisitor;
5128			impl<'de> Visitor<'de> for ClassVisitor {
5129				type Value = VideoGame;
5130				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
5131					formatter.write_str("schema.org schema VideoGame")
5132				}
5133				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
5134				where
5135					A: de::MapAccess<'de>,
5136				{
5137					let mut r#actor_property = None;
5138					let mut r#actors_property = None;
5139					let mut r#cheat_code_property = None;
5140					let mut r#director_property = None;
5141					let mut r#directors_property = None;
5142					let mut r#game_edition_property = None;
5143					let mut r#game_platform_property = None;
5144					let mut r#game_server_property = None;
5145					let mut r#game_tip_property = None;
5146					let mut r#music_by_property = None;
5147					let mut r#play_mode_property = None;
5148					let mut r#trailer_property = None;
5149					let mut r#about_property = None;
5150					let mut r#abstract_property = None;
5151					let mut r#access_mode_property = None;
5152					let mut r#access_mode_sufficient_property = None;
5153					let mut r#accessibility_api_property = None;
5154					let mut r#accessibility_control_property = None;
5155					let mut r#accessibility_feature_property = None;
5156					let mut r#accessibility_hazard_property = None;
5157					let mut r#accessibility_summary_property = None;
5158					let mut r#accountable_person_property = None;
5159					let mut r#acquire_license_page_property = None;
5160					let mut r#aggregate_rating_property = None;
5161					let mut r#alternative_headline_property = None;
5162					let mut r#archived_at_property = None;
5163					let mut r#assesses_property = None;
5164					let mut r#associated_media_property = None;
5165					let mut r#audience_property = None;
5166					let mut r#audio_property = None;
5167					let mut r#author_property = None;
5168					let mut r#award_property = None;
5169					let mut r#awards_property = None;
5170					let mut r#character_property = None;
5171					let mut r#citation_property = None;
5172					let mut r#comment_property = None;
5173					let mut r#comment_count_property = None;
5174					let mut r#conditions_of_access_property = None;
5175					let mut r#content_location_property = None;
5176					let mut r#content_rating_property = None;
5177					let mut r#content_reference_time_property = None;
5178					let mut r#contributor_property = None;
5179					let mut r#copyright_holder_property = None;
5180					let mut r#copyright_notice_property = None;
5181					let mut r#copyright_year_property = None;
5182					let mut r#correction_property = None;
5183					let mut r#country_of_origin_property = None;
5184					let mut r#creative_work_status_property = None;
5185					let mut r#creator_property = None;
5186					let mut r#credit_text_property = None;
5187					let mut r#date_created_property = None;
5188					let mut r#date_modified_property = None;
5189					let mut r#date_published_property = None;
5190					let mut r#discussion_url_property = None;
5191					let mut r#edit_eidr_property = None;
5192					let mut r#editor_property = None;
5193					let mut r#educational_alignment_property = None;
5194					let mut r#educational_level_property = None;
5195					let mut r#educational_use_property = None;
5196					let mut r#encoding_property = None;
5197					let mut r#encoding_format_property = None;
5198					let mut r#encodings_property = None;
5199					let mut r#example_of_work_property = None;
5200					let mut r#expires_property = None;
5201					let mut r#file_format_property = None;
5202					let mut r#funder_property = None;
5203					let mut r#funding_property = None;
5204					let mut r#genre_property = None;
5205					let mut r#has_part_property = None;
5206					let mut r#headline_property = None;
5207					let mut r#in_language_property = None;
5208					let mut r#interaction_statistic_property = None;
5209					let mut r#interactivity_type_property = None;
5210					let mut r#interpreted_as_claim_property = None;
5211					let mut r#is_accessible_for_free_property = None;
5212					let mut r#is_based_on_property = None;
5213					let mut r#is_based_on_url_property = None;
5214					let mut r#is_family_friendly_property = None;
5215					let mut r#is_part_of_property = None;
5216					let mut r#keywords_property = None;
5217					let mut r#learning_resource_type_property = None;
5218					let mut r#license_property = None;
5219					let mut r#location_created_property = None;
5220					let mut r#main_entity_property = None;
5221					let mut r#maintainer_property = None;
5222					let mut r#material_property = None;
5223					let mut r#material_extent_property = None;
5224					let mut r#mentions_property = None;
5225					let mut r#offers_property = None;
5226					let mut r#pattern_property = None;
5227					let mut r#position_property = None;
5228					let mut r#producer_property = None;
5229					let mut r#provider_property = None;
5230					let mut r#publication_property = None;
5231					let mut r#publisher_property = None;
5232					let mut r#publisher_imprint_property = None;
5233					let mut r#publishing_principles_property = None;
5234					let mut r#recorded_at_property = None;
5235					let mut r#released_event_property = None;
5236					let mut r#review_property = None;
5237					let mut r#reviews_property = None;
5238					let mut r#schema_version_property = None;
5239					let mut r#sd_date_published_property = None;
5240					let mut r#sd_license_property = None;
5241					let mut r#sd_publisher_property = None;
5242					let mut r#size_property = None;
5243					let mut r#source_organization_property = None;
5244					let mut r#spatial_property = None;
5245					let mut r#spatial_coverage_property = None;
5246					let mut r#sponsor_property = None;
5247					let mut r#teaches_property = None;
5248					let mut r#temporal_property = None;
5249					let mut r#temporal_coverage_property = None;
5250					let mut r#text_property = None;
5251					let mut r#thumbnail_property = None;
5252					let mut r#thumbnail_url_property = None;
5253					let mut r#time_required_property = None;
5254					let mut r#translation_of_work_property = None;
5255					let mut r#translator_property = None;
5256					let mut r#typical_age_range_property = None;
5257					let mut r#usage_info_property = None;
5258					let mut r#version_property = None;
5259					let mut r#video_property = None;
5260					let mut r#work_example_property = None;
5261					let mut r#work_translation_property = None;
5262					let mut r#character_attribute_property = None;
5263					let mut r#game_item_property = None;
5264					let mut r#game_location_property = None;
5265					let mut r#number_of_players_property = None;
5266					let mut r#quest_property = None;
5267					let mut r#application_category_property = None;
5268					let mut r#application_sub_category_property = None;
5269					let mut r#application_suite_property = None;
5270					let mut r#available_on_device_property = None;
5271					let mut r#countries_not_supported_property = None;
5272					let mut r#countries_supported_property = None;
5273					let mut r#device_property = None;
5274					let mut r#download_url_property = None;
5275					let mut r#feature_list_property = None;
5276					let mut r#file_size_property = None;
5277					let mut r#install_url_property = None;
5278					let mut r#memory_requirements_property = None;
5279					let mut r#operating_system_property = None;
5280					let mut r#permissions_property = None;
5281					let mut r#processor_requirements_property = None;
5282					let mut r#release_notes_property = None;
5283					let mut r#requirements_property = None;
5284					let mut r#screenshot_property = None;
5285					let mut r#software_add_on_property = None;
5286					let mut r#software_help_property = None;
5287					let mut r#software_requirements_property = None;
5288					let mut r#software_version_property = None;
5289					let mut r#storage_requirements_property = None;
5290					let mut r#supporting_data_property = None;
5291					let mut r#additional_type_property = None;
5292					let mut r#alternate_name_property = None;
5293					let mut r#description_property = None;
5294					let mut r#disambiguating_description_property = None;
5295					let mut r#identifier_property = None;
5296					let mut r#image_property = None;
5297					let mut r#main_entity_of_page_property = None;
5298					let mut r#name_property = None;
5299					let mut r#potential_action_property = None;
5300					let mut r#same_as_property = None;
5301					let mut r#subject_of_property = None;
5302					let mut r#url_property = None;
5303					while let Some(key) = map.next_key::<Field>()? {
5304						match key {
5305							Field::Actor => {
5306								if r#actor_property.is_some() {
5307									return Err(<A::Error as de::Error>::duplicate_field("actor"));
5308								}
5309								r#actor_property = Some({
5310									struct DeserializeWith(Vec<ActorProperty>);
5311									impl<'de> Deserialize<'de> for DeserializeWith {
5312										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5313										where
5314											D: Deserializer<'de>,
5315										{
5316											Ok(DeserializeWith(serde_with::As::<
5317												serde_with::OneOrMany<serde_with::Same>,
5318											>::deserialize(deserializer)?))
5319										}
5320									}
5321									match map.next_value::<DeserializeWith>() {
5322										Ok(deserialize_with) => deserialize_with.0,
5323										Err(err) => {
5324											return Err(err);
5325										}
5326									}
5327								});
5328							}
5329							Field::Actors => {
5330								if r#actors_property.is_some() {
5331									return Err(<A::Error as de::Error>::duplicate_field("actors"));
5332								}
5333								r#actors_property = Some({
5334									struct DeserializeWith(Vec<ActorsProperty>);
5335									impl<'de> Deserialize<'de> for DeserializeWith {
5336										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5337										where
5338											D: Deserializer<'de>,
5339										{
5340											Ok(DeserializeWith(serde_with::As::<
5341												serde_with::OneOrMany<serde_with::Same>,
5342											>::deserialize(deserializer)?))
5343										}
5344									}
5345									match map.next_value::<DeserializeWith>() {
5346										Ok(deserialize_with) => deserialize_with.0,
5347										Err(err) => {
5348											return Err(err);
5349										}
5350									}
5351								});
5352							}
5353							Field::CheatCode => {
5354								if r#cheat_code_property.is_some() {
5355									return Err(<A::Error as de::Error>::duplicate_field(
5356										"cheatCode",
5357									));
5358								}
5359								r#cheat_code_property = Some({
5360									struct DeserializeWith(Vec<CheatCodeProperty>);
5361									impl<'de> Deserialize<'de> for DeserializeWith {
5362										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5363										where
5364											D: Deserializer<'de>,
5365										{
5366											Ok(DeserializeWith(serde_with::As::<
5367												serde_with::OneOrMany<serde_with::Same>,
5368											>::deserialize(deserializer)?))
5369										}
5370									}
5371									match map.next_value::<DeserializeWith>() {
5372										Ok(deserialize_with) => deserialize_with.0,
5373										Err(err) => {
5374											return Err(err);
5375										}
5376									}
5377								});
5378							}
5379							Field::Director => {
5380								if r#director_property.is_some() {
5381									return Err(<A::Error as de::Error>::duplicate_field(
5382										"director",
5383									));
5384								}
5385								r#director_property = Some({
5386									struct DeserializeWith(Vec<DirectorProperty>);
5387									impl<'de> Deserialize<'de> for DeserializeWith {
5388										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5389										where
5390											D: Deserializer<'de>,
5391										{
5392											Ok(DeserializeWith(serde_with::As::<
5393												serde_with::OneOrMany<serde_with::Same>,
5394											>::deserialize(deserializer)?))
5395										}
5396									}
5397									match map.next_value::<DeserializeWith>() {
5398										Ok(deserialize_with) => deserialize_with.0,
5399										Err(err) => {
5400											return Err(err);
5401										}
5402									}
5403								});
5404							}
5405							Field::Directors => {
5406								if r#directors_property.is_some() {
5407									return Err(<A::Error as de::Error>::duplicate_field(
5408										"directors",
5409									));
5410								}
5411								r#directors_property = Some({
5412									struct DeserializeWith(Vec<DirectorsProperty>);
5413									impl<'de> Deserialize<'de> for DeserializeWith {
5414										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5415										where
5416											D: Deserializer<'de>,
5417										{
5418											Ok(DeserializeWith(serde_with::As::<
5419												serde_with::OneOrMany<serde_with::Same>,
5420											>::deserialize(deserializer)?))
5421										}
5422									}
5423									match map.next_value::<DeserializeWith>() {
5424										Ok(deserialize_with) => deserialize_with.0,
5425										Err(err) => {
5426											return Err(err);
5427										}
5428									}
5429								});
5430							}
5431							Field::GameEdition => {
5432								if r#game_edition_property.is_some() {
5433									return Err(<A::Error as de::Error>::duplicate_field(
5434										"gameEdition",
5435									));
5436								}
5437								r#game_edition_property = Some({
5438									struct DeserializeWith(Vec<GameEditionProperty>);
5439									impl<'de> Deserialize<'de> for DeserializeWith {
5440										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5441										where
5442											D: Deserializer<'de>,
5443										{
5444											Ok(DeserializeWith(serde_with::As::<
5445												serde_with::OneOrMany<serde_with::Same>,
5446											>::deserialize(deserializer)?))
5447										}
5448									}
5449									match map.next_value::<DeserializeWith>() {
5450										Ok(deserialize_with) => deserialize_with.0,
5451										Err(err) => {
5452											return Err(err);
5453										}
5454									}
5455								});
5456							}
5457							Field::GamePlatform => {
5458								if r#game_platform_property.is_some() {
5459									return Err(<A::Error as de::Error>::duplicate_field(
5460										"gamePlatform",
5461									));
5462								}
5463								r#game_platform_property = Some({
5464									struct DeserializeWith(Vec<GamePlatformProperty>);
5465									impl<'de> Deserialize<'de> for DeserializeWith {
5466										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5467										where
5468											D: Deserializer<'de>,
5469										{
5470											Ok(DeserializeWith(serde_with::As::<
5471												serde_with::OneOrMany<serde_with::Same>,
5472											>::deserialize(deserializer)?))
5473										}
5474									}
5475									match map.next_value::<DeserializeWith>() {
5476										Ok(deserialize_with) => deserialize_with.0,
5477										Err(err) => {
5478											return Err(err);
5479										}
5480									}
5481								});
5482							}
5483							Field::GameServer => {
5484								if r#game_server_property.is_some() {
5485									return Err(<A::Error as de::Error>::duplicate_field(
5486										"gameServer",
5487									));
5488								}
5489								r#game_server_property = Some({
5490									struct DeserializeWith(Vec<GameServerProperty>);
5491									impl<'de> Deserialize<'de> for DeserializeWith {
5492										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5493										where
5494											D: Deserializer<'de>,
5495										{
5496											Ok(DeserializeWith(serde_with::As::<
5497												serde_with::OneOrMany<serde_with::Same>,
5498											>::deserialize(deserializer)?))
5499										}
5500									}
5501									match map.next_value::<DeserializeWith>() {
5502										Ok(deserialize_with) => deserialize_with.0,
5503										Err(err) => {
5504											return Err(err);
5505										}
5506									}
5507								});
5508							}
5509							Field::GameTip => {
5510								if r#game_tip_property.is_some() {
5511									return Err(<A::Error as de::Error>::duplicate_field(
5512										"gameTip",
5513									));
5514								}
5515								r#game_tip_property = Some({
5516									struct DeserializeWith(Vec<GameTipProperty>);
5517									impl<'de> Deserialize<'de> for DeserializeWith {
5518										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5519										where
5520											D: Deserializer<'de>,
5521										{
5522											Ok(DeserializeWith(serde_with::As::<
5523												serde_with::OneOrMany<serde_with::Same>,
5524											>::deserialize(deserializer)?))
5525										}
5526									}
5527									match map.next_value::<DeserializeWith>() {
5528										Ok(deserialize_with) => deserialize_with.0,
5529										Err(err) => {
5530											return Err(err);
5531										}
5532									}
5533								});
5534							}
5535							Field::MusicBy => {
5536								if r#music_by_property.is_some() {
5537									return Err(<A::Error as de::Error>::duplicate_field(
5538										"musicBy",
5539									));
5540								}
5541								r#music_by_property = Some({
5542									struct DeserializeWith(Vec<MusicByProperty>);
5543									impl<'de> Deserialize<'de> for DeserializeWith {
5544										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5545										where
5546											D: Deserializer<'de>,
5547										{
5548											Ok(DeserializeWith(serde_with::As::<
5549												serde_with::OneOrMany<serde_with::Same>,
5550											>::deserialize(deserializer)?))
5551										}
5552									}
5553									match map.next_value::<DeserializeWith>() {
5554										Ok(deserialize_with) => deserialize_with.0,
5555										Err(err) => {
5556											return Err(err);
5557										}
5558									}
5559								});
5560							}
5561							Field::PlayMode => {
5562								if r#play_mode_property.is_some() {
5563									return Err(<A::Error as de::Error>::duplicate_field(
5564										"playMode",
5565									));
5566								}
5567								r#play_mode_property = Some({
5568									struct DeserializeWith(Vec<PlayModeProperty>);
5569									impl<'de> Deserialize<'de> for DeserializeWith {
5570										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5571										where
5572											D: Deserializer<'de>,
5573										{
5574											Ok(DeserializeWith(serde_with::As::<
5575												serde_with::OneOrMany<serde_with::Same>,
5576											>::deserialize(deserializer)?))
5577										}
5578									}
5579									match map.next_value::<DeserializeWith>() {
5580										Ok(deserialize_with) => deserialize_with.0,
5581										Err(err) => {
5582											return Err(err);
5583										}
5584									}
5585								});
5586							}
5587							Field::Trailer => {
5588								if r#trailer_property.is_some() {
5589									return Err(<A::Error as de::Error>::duplicate_field(
5590										"trailer",
5591									));
5592								}
5593								r#trailer_property = Some({
5594									struct DeserializeWith(Vec<TrailerProperty>);
5595									impl<'de> Deserialize<'de> for DeserializeWith {
5596										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5597										where
5598											D: Deserializer<'de>,
5599										{
5600											Ok(DeserializeWith(serde_with::As::<
5601												serde_with::OneOrMany<serde_with::Same>,
5602											>::deserialize(deserializer)?))
5603										}
5604									}
5605									match map.next_value::<DeserializeWith>() {
5606										Ok(deserialize_with) => deserialize_with.0,
5607										Err(err) => {
5608											return Err(err);
5609										}
5610									}
5611								});
5612							}
5613							Field::About => {
5614								if r#about_property.is_some() {
5615									return Err(<A::Error as de::Error>::duplicate_field("about"));
5616								}
5617								r#about_property = Some({
5618									struct DeserializeWith(Vec<AboutProperty>);
5619									impl<'de> Deserialize<'de> for DeserializeWith {
5620										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5621										where
5622											D: Deserializer<'de>,
5623										{
5624											Ok(DeserializeWith(serde_with::As::<
5625												serde_with::OneOrMany<serde_with::Same>,
5626											>::deserialize(deserializer)?))
5627										}
5628									}
5629									match map.next_value::<DeserializeWith>() {
5630										Ok(deserialize_with) => deserialize_with.0,
5631										Err(err) => {
5632											return Err(err);
5633										}
5634									}
5635								});
5636							}
5637							Field::Abstract => {
5638								if r#abstract_property.is_some() {
5639									return Err(<A::Error as de::Error>::duplicate_field(
5640										"abstract",
5641									));
5642								}
5643								r#abstract_property = Some({
5644									struct DeserializeWith(Vec<AbstractProperty>);
5645									impl<'de> Deserialize<'de> for DeserializeWith {
5646										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5647										where
5648											D: Deserializer<'de>,
5649										{
5650											Ok(DeserializeWith(serde_with::As::<
5651												serde_with::OneOrMany<serde_with::Same>,
5652											>::deserialize(deserializer)?))
5653										}
5654									}
5655									match map.next_value::<DeserializeWith>() {
5656										Ok(deserialize_with) => deserialize_with.0,
5657										Err(err) => {
5658											return Err(err);
5659										}
5660									}
5661								});
5662							}
5663							Field::AccessMode => {
5664								if r#access_mode_property.is_some() {
5665									return Err(<A::Error as de::Error>::duplicate_field(
5666										"accessMode",
5667									));
5668								}
5669								r#access_mode_property = Some({
5670									struct DeserializeWith(Vec<AccessModeProperty>);
5671									impl<'de> Deserialize<'de> for DeserializeWith {
5672										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5673										where
5674											D: Deserializer<'de>,
5675										{
5676											Ok(DeserializeWith(serde_with::As::<
5677												serde_with::OneOrMany<serde_with::Same>,
5678											>::deserialize(deserializer)?))
5679										}
5680									}
5681									match map.next_value::<DeserializeWith>() {
5682										Ok(deserialize_with) => deserialize_with.0,
5683										Err(err) => {
5684											return Err(err);
5685										}
5686									}
5687								});
5688							}
5689							Field::AccessModeSufficient => {
5690								if r#access_mode_sufficient_property.is_some() {
5691									return Err(<A::Error as de::Error>::duplicate_field(
5692										"accessModeSufficient",
5693									));
5694								}
5695								r#access_mode_sufficient_property = Some({
5696									struct DeserializeWith(Vec<AccessModeSufficientProperty>);
5697									impl<'de> Deserialize<'de> for DeserializeWith {
5698										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5699										where
5700											D: Deserializer<'de>,
5701										{
5702											Ok(DeserializeWith(serde_with::As::<
5703												serde_with::OneOrMany<serde_with::Same>,
5704											>::deserialize(deserializer)?))
5705										}
5706									}
5707									match map.next_value::<DeserializeWith>() {
5708										Ok(deserialize_with) => deserialize_with.0,
5709										Err(err) => {
5710											return Err(err);
5711										}
5712									}
5713								});
5714							}
5715							Field::AccessibilityApi => {
5716								if r#accessibility_api_property.is_some() {
5717									return Err(<A::Error as de::Error>::duplicate_field(
5718										"accessibilityAPI",
5719									));
5720								}
5721								r#accessibility_api_property = Some({
5722									struct DeserializeWith(Vec<AccessibilityApiProperty>);
5723									impl<'de> Deserialize<'de> for DeserializeWith {
5724										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5725										where
5726											D: Deserializer<'de>,
5727										{
5728											Ok(DeserializeWith(serde_with::As::<
5729												serde_with::OneOrMany<serde_with::Same>,
5730											>::deserialize(deserializer)?))
5731										}
5732									}
5733									match map.next_value::<DeserializeWith>() {
5734										Ok(deserialize_with) => deserialize_with.0,
5735										Err(err) => {
5736											return Err(err);
5737										}
5738									}
5739								});
5740							}
5741							Field::AccessibilityControl => {
5742								if r#accessibility_control_property.is_some() {
5743									return Err(<A::Error as de::Error>::duplicate_field(
5744										"accessibilityControl",
5745									));
5746								}
5747								r#accessibility_control_property = Some({
5748									struct DeserializeWith(Vec<AccessibilityControlProperty>);
5749									impl<'de> Deserialize<'de> for DeserializeWith {
5750										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5751										where
5752											D: Deserializer<'de>,
5753										{
5754											Ok(DeserializeWith(serde_with::As::<
5755												serde_with::OneOrMany<serde_with::Same>,
5756											>::deserialize(deserializer)?))
5757										}
5758									}
5759									match map.next_value::<DeserializeWith>() {
5760										Ok(deserialize_with) => deserialize_with.0,
5761										Err(err) => {
5762											return Err(err);
5763										}
5764									}
5765								});
5766							}
5767							Field::AccessibilityFeature => {
5768								if r#accessibility_feature_property.is_some() {
5769									return Err(<A::Error as de::Error>::duplicate_field(
5770										"accessibilityFeature",
5771									));
5772								}
5773								r#accessibility_feature_property = Some({
5774									struct DeserializeWith(Vec<AccessibilityFeatureProperty>);
5775									impl<'de> Deserialize<'de> for DeserializeWith {
5776										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5777										where
5778											D: Deserializer<'de>,
5779										{
5780											Ok(DeserializeWith(serde_with::As::<
5781												serde_with::OneOrMany<serde_with::Same>,
5782											>::deserialize(deserializer)?))
5783										}
5784									}
5785									match map.next_value::<DeserializeWith>() {
5786										Ok(deserialize_with) => deserialize_with.0,
5787										Err(err) => {
5788											return Err(err);
5789										}
5790									}
5791								});
5792							}
5793							Field::AccessibilityHazard => {
5794								if r#accessibility_hazard_property.is_some() {
5795									return Err(<A::Error as de::Error>::duplicate_field(
5796										"accessibilityHazard",
5797									));
5798								}
5799								r#accessibility_hazard_property = Some({
5800									struct DeserializeWith(Vec<AccessibilityHazardProperty>);
5801									impl<'de> Deserialize<'de> for DeserializeWith {
5802										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5803										where
5804											D: Deserializer<'de>,
5805										{
5806											Ok(DeserializeWith(serde_with::As::<
5807												serde_with::OneOrMany<serde_with::Same>,
5808											>::deserialize(deserializer)?))
5809										}
5810									}
5811									match map.next_value::<DeserializeWith>() {
5812										Ok(deserialize_with) => deserialize_with.0,
5813										Err(err) => {
5814											return Err(err);
5815										}
5816									}
5817								});
5818							}
5819							Field::AccessibilitySummary => {
5820								if r#accessibility_summary_property.is_some() {
5821									return Err(<A::Error as de::Error>::duplicate_field(
5822										"accessibilitySummary",
5823									));
5824								}
5825								r#accessibility_summary_property = Some({
5826									struct DeserializeWith(Vec<AccessibilitySummaryProperty>);
5827									impl<'de> Deserialize<'de> for DeserializeWith {
5828										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5829										where
5830											D: Deserializer<'de>,
5831										{
5832											Ok(DeserializeWith(serde_with::As::<
5833												serde_with::OneOrMany<serde_with::Same>,
5834											>::deserialize(deserializer)?))
5835										}
5836									}
5837									match map.next_value::<DeserializeWith>() {
5838										Ok(deserialize_with) => deserialize_with.0,
5839										Err(err) => {
5840											return Err(err);
5841										}
5842									}
5843								});
5844							}
5845							Field::AccountablePerson => {
5846								if r#accountable_person_property.is_some() {
5847									return Err(<A::Error as de::Error>::duplicate_field(
5848										"accountablePerson",
5849									));
5850								}
5851								r#accountable_person_property = Some({
5852									struct DeserializeWith(Vec<AccountablePersonProperty>);
5853									impl<'de> Deserialize<'de> for DeserializeWith {
5854										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5855										where
5856											D: Deserializer<'de>,
5857										{
5858											Ok(DeserializeWith(serde_with::As::<
5859												serde_with::OneOrMany<serde_with::Same>,
5860											>::deserialize(deserializer)?))
5861										}
5862									}
5863									match map.next_value::<DeserializeWith>() {
5864										Ok(deserialize_with) => deserialize_with.0,
5865										Err(err) => {
5866											return Err(err);
5867										}
5868									}
5869								});
5870							}
5871							Field::AcquireLicensePage => {
5872								if r#acquire_license_page_property.is_some() {
5873									return Err(<A::Error as de::Error>::duplicate_field(
5874										"acquireLicensePage",
5875									));
5876								}
5877								r#acquire_license_page_property = Some({
5878									struct DeserializeWith(Vec<AcquireLicensePageProperty>);
5879									impl<'de> Deserialize<'de> for DeserializeWith {
5880										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5881										where
5882											D: Deserializer<'de>,
5883										{
5884											Ok(DeserializeWith(serde_with::As::<
5885												serde_with::OneOrMany<serde_with::Same>,
5886											>::deserialize(deserializer)?))
5887										}
5888									}
5889									match map.next_value::<DeserializeWith>() {
5890										Ok(deserialize_with) => deserialize_with.0,
5891										Err(err) => {
5892											return Err(err);
5893										}
5894									}
5895								});
5896							}
5897							Field::AggregateRating => {
5898								if r#aggregate_rating_property.is_some() {
5899									return Err(<A::Error as de::Error>::duplicate_field(
5900										"aggregateRating",
5901									));
5902								}
5903								r#aggregate_rating_property = Some({
5904									struct DeserializeWith(Vec<AggregateRatingProperty>);
5905									impl<'de> Deserialize<'de> for DeserializeWith {
5906										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5907										where
5908											D: Deserializer<'de>,
5909										{
5910											Ok(DeserializeWith(serde_with::As::<
5911												serde_with::OneOrMany<serde_with::Same>,
5912											>::deserialize(deserializer)?))
5913										}
5914									}
5915									match map.next_value::<DeserializeWith>() {
5916										Ok(deserialize_with) => deserialize_with.0,
5917										Err(err) => {
5918											return Err(err);
5919										}
5920									}
5921								});
5922							}
5923							Field::AlternativeHeadline => {
5924								if r#alternative_headline_property.is_some() {
5925									return Err(<A::Error as de::Error>::duplicate_field(
5926										"alternativeHeadline",
5927									));
5928								}
5929								r#alternative_headline_property = Some({
5930									struct DeserializeWith(Vec<AlternativeHeadlineProperty>);
5931									impl<'de> Deserialize<'de> for DeserializeWith {
5932										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5933										where
5934											D: Deserializer<'de>,
5935										{
5936											Ok(DeserializeWith(serde_with::As::<
5937												serde_with::OneOrMany<serde_with::Same>,
5938											>::deserialize(deserializer)?))
5939										}
5940									}
5941									match map.next_value::<DeserializeWith>() {
5942										Ok(deserialize_with) => deserialize_with.0,
5943										Err(err) => {
5944											return Err(err);
5945										}
5946									}
5947								});
5948							}
5949							Field::ArchivedAt => {
5950								if r#archived_at_property.is_some() {
5951									return Err(<A::Error as de::Error>::duplicate_field(
5952										"archivedAt",
5953									));
5954								}
5955								r#archived_at_property = Some({
5956									struct DeserializeWith(Vec<ArchivedAtProperty>);
5957									impl<'de> Deserialize<'de> for DeserializeWith {
5958										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5959										where
5960											D: Deserializer<'de>,
5961										{
5962											Ok(DeserializeWith(serde_with::As::<
5963												serde_with::OneOrMany<serde_with::Same>,
5964											>::deserialize(deserializer)?))
5965										}
5966									}
5967									match map.next_value::<DeserializeWith>() {
5968										Ok(deserialize_with) => deserialize_with.0,
5969										Err(err) => {
5970											return Err(err);
5971										}
5972									}
5973								});
5974							}
5975							Field::Assesses => {
5976								if r#assesses_property.is_some() {
5977									return Err(<A::Error as de::Error>::duplicate_field(
5978										"assesses",
5979									));
5980								}
5981								r#assesses_property = Some({
5982									struct DeserializeWith(Vec<AssessesProperty>);
5983									impl<'de> Deserialize<'de> for DeserializeWith {
5984										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5985										where
5986											D: Deserializer<'de>,
5987										{
5988											Ok(DeserializeWith(serde_with::As::<
5989												serde_with::OneOrMany<serde_with::Same>,
5990											>::deserialize(deserializer)?))
5991										}
5992									}
5993									match map.next_value::<DeserializeWith>() {
5994										Ok(deserialize_with) => deserialize_with.0,
5995										Err(err) => {
5996											return Err(err);
5997										}
5998									}
5999								});
6000							}
6001							Field::AssociatedMedia => {
6002								if r#associated_media_property.is_some() {
6003									return Err(<A::Error as de::Error>::duplicate_field(
6004										"associatedMedia",
6005									));
6006								}
6007								r#associated_media_property = Some({
6008									struct DeserializeWith(Vec<AssociatedMediaProperty>);
6009									impl<'de> Deserialize<'de> for DeserializeWith {
6010										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6011										where
6012											D: Deserializer<'de>,
6013										{
6014											Ok(DeserializeWith(serde_with::As::<
6015												serde_with::OneOrMany<serde_with::Same>,
6016											>::deserialize(deserializer)?))
6017										}
6018									}
6019									match map.next_value::<DeserializeWith>() {
6020										Ok(deserialize_with) => deserialize_with.0,
6021										Err(err) => {
6022											return Err(err);
6023										}
6024									}
6025								});
6026							}
6027							Field::Audience => {
6028								if r#audience_property.is_some() {
6029									return Err(<A::Error as de::Error>::duplicate_field(
6030										"audience",
6031									));
6032								}
6033								r#audience_property = Some({
6034									struct DeserializeWith(Vec<AudienceProperty>);
6035									impl<'de> Deserialize<'de> for DeserializeWith {
6036										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6037										where
6038											D: Deserializer<'de>,
6039										{
6040											Ok(DeserializeWith(serde_with::As::<
6041												serde_with::OneOrMany<serde_with::Same>,
6042											>::deserialize(deserializer)?))
6043										}
6044									}
6045									match map.next_value::<DeserializeWith>() {
6046										Ok(deserialize_with) => deserialize_with.0,
6047										Err(err) => {
6048											return Err(err);
6049										}
6050									}
6051								});
6052							}
6053							Field::Audio => {
6054								if r#audio_property.is_some() {
6055									return Err(<A::Error as de::Error>::duplicate_field("audio"));
6056								}
6057								r#audio_property = Some({
6058									struct DeserializeWith(Vec<AudioProperty>);
6059									impl<'de> Deserialize<'de> for DeserializeWith {
6060										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6061										where
6062											D: Deserializer<'de>,
6063										{
6064											Ok(DeserializeWith(serde_with::As::<
6065												serde_with::OneOrMany<serde_with::Same>,
6066											>::deserialize(deserializer)?))
6067										}
6068									}
6069									match map.next_value::<DeserializeWith>() {
6070										Ok(deserialize_with) => deserialize_with.0,
6071										Err(err) => {
6072											return Err(err);
6073										}
6074									}
6075								});
6076							}
6077							Field::Author => {
6078								if r#author_property.is_some() {
6079									return Err(<A::Error as de::Error>::duplicate_field("author"));
6080								}
6081								r#author_property = Some({
6082									struct DeserializeWith(Vec<AuthorProperty>);
6083									impl<'de> Deserialize<'de> for DeserializeWith {
6084										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6085										where
6086											D: Deserializer<'de>,
6087										{
6088											Ok(DeserializeWith(serde_with::As::<
6089												serde_with::OneOrMany<serde_with::Same>,
6090											>::deserialize(deserializer)?))
6091										}
6092									}
6093									match map.next_value::<DeserializeWith>() {
6094										Ok(deserialize_with) => deserialize_with.0,
6095										Err(err) => {
6096											return Err(err);
6097										}
6098									}
6099								});
6100							}
6101							Field::Award => {
6102								if r#award_property.is_some() {
6103									return Err(<A::Error as de::Error>::duplicate_field("award"));
6104								}
6105								r#award_property = Some({
6106									struct DeserializeWith(Vec<AwardProperty>);
6107									impl<'de> Deserialize<'de> for DeserializeWith {
6108										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6109										where
6110											D: Deserializer<'de>,
6111										{
6112											Ok(DeserializeWith(serde_with::As::<
6113												serde_with::OneOrMany<serde_with::Same>,
6114											>::deserialize(deserializer)?))
6115										}
6116									}
6117									match map.next_value::<DeserializeWith>() {
6118										Ok(deserialize_with) => deserialize_with.0,
6119										Err(err) => {
6120											return Err(err);
6121										}
6122									}
6123								});
6124							}
6125							Field::Awards => {
6126								if r#awards_property.is_some() {
6127									return Err(<A::Error as de::Error>::duplicate_field("awards"));
6128								}
6129								r#awards_property = Some({
6130									struct DeserializeWith(Vec<AwardsProperty>);
6131									impl<'de> Deserialize<'de> for DeserializeWith {
6132										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6133										where
6134											D: Deserializer<'de>,
6135										{
6136											Ok(DeserializeWith(serde_with::As::<
6137												serde_with::OneOrMany<serde_with::Same>,
6138											>::deserialize(deserializer)?))
6139										}
6140									}
6141									match map.next_value::<DeserializeWith>() {
6142										Ok(deserialize_with) => deserialize_with.0,
6143										Err(err) => {
6144											return Err(err);
6145										}
6146									}
6147								});
6148							}
6149							Field::Character => {
6150								if r#character_property.is_some() {
6151									return Err(<A::Error as de::Error>::duplicate_field(
6152										"character",
6153									));
6154								}
6155								r#character_property = Some({
6156									struct DeserializeWith(Vec<CharacterProperty>);
6157									impl<'de> Deserialize<'de> for DeserializeWith {
6158										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6159										where
6160											D: Deserializer<'de>,
6161										{
6162											Ok(DeserializeWith(serde_with::As::<
6163												serde_with::OneOrMany<serde_with::Same>,
6164											>::deserialize(deserializer)?))
6165										}
6166									}
6167									match map.next_value::<DeserializeWith>() {
6168										Ok(deserialize_with) => deserialize_with.0,
6169										Err(err) => {
6170											return Err(err);
6171										}
6172									}
6173								});
6174							}
6175							Field::Citation => {
6176								if r#citation_property.is_some() {
6177									return Err(<A::Error as de::Error>::duplicate_field(
6178										"citation",
6179									));
6180								}
6181								r#citation_property = Some({
6182									struct DeserializeWith(Vec<CitationProperty>);
6183									impl<'de> Deserialize<'de> for DeserializeWith {
6184										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6185										where
6186											D: Deserializer<'de>,
6187										{
6188											Ok(DeserializeWith(serde_with::As::<
6189												serde_with::OneOrMany<serde_with::Same>,
6190											>::deserialize(deserializer)?))
6191										}
6192									}
6193									match map.next_value::<DeserializeWith>() {
6194										Ok(deserialize_with) => deserialize_with.0,
6195										Err(err) => {
6196											return Err(err);
6197										}
6198									}
6199								});
6200							}
6201							Field::Comment => {
6202								if r#comment_property.is_some() {
6203									return Err(<A::Error as de::Error>::duplicate_field(
6204										"comment",
6205									));
6206								}
6207								r#comment_property = Some({
6208									struct DeserializeWith(Vec<CommentProperty>);
6209									impl<'de> Deserialize<'de> for DeserializeWith {
6210										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6211										where
6212											D: Deserializer<'de>,
6213										{
6214											Ok(DeserializeWith(serde_with::As::<
6215												serde_with::OneOrMany<serde_with::Same>,
6216											>::deserialize(deserializer)?))
6217										}
6218									}
6219									match map.next_value::<DeserializeWith>() {
6220										Ok(deserialize_with) => deserialize_with.0,
6221										Err(err) => {
6222											return Err(err);
6223										}
6224									}
6225								});
6226							}
6227							Field::CommentCount => {
6228								if r#comment_count_property.is_some() {
6229									return Err(<A::Error as de::Error>::duplicate_field(
6230										"commentCount",
6231									));
6232								}
6233								r#comment_count_property = Some({
6234									struct DeserializeWith(Vec<CommentCountProperty>);
6235									impl<'de> Deserialize<'de> for DeserializeWith {
6236										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6237										where
6238											D: Deserializer<'de>,
6239										{
6240											Ok(DeserializeWith(serde_with::As::<
6241												serde_with::OneOrMany<serde_with::Same>,
6242											>::deserialize(deserializer)?))
6243										}
6244									}
6245									match map.next_value::<DeserializeWith>() {
6246										Ok(deserialize_with) => deserialize_with.0,
6247										Err(err) => {
6248											return Err(err);
6249										}
6250									}
6251								});
6252							}
6253							Field::ConditionsOfAccess => {
6254								if r#conditions_of_access_property.is_some() {
6255									return Err(<A::Error as de::Error>::duplicate_field(
6256										"conditionsOfAccess",
6257									));
6258								}
6259								r#conditions_of_access_property = Some({
6260									struct DeserializeWith(Vec<ConditionsOfAccessProperty>);
6261									impl<'de> Deserialize<'de> for DeserializeWith {
6262										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6263										where
6264											D: Deserializer<'de>,
6265										{
6266											Ok(DeserializeWith(serde_with::As::<
6267												serde_with::OneOrMany<serde_with::Same>,
6268											>::deserialize(deserializer)?))
6269										}
6270									}
6271									match map.next_value::<DeserializeWith>() {
6272										Ok(deserialize_with) => deserialize_with.0,
6273										Err(err) => {
6274											return Err(err);
6275										}
6276									}
6277								});
6278							}
6279							Field::ContentLocation => {
6280								if r#content_location_property.is_some() {
6281									return Err(<A::Error as de::Error>::duplicate_field(
6282										"contentLocation",
6283									));
6284								}
6285								r#content_location_property = Some({
6286									struct DeserializeWith(Vec<ContentLocationProperty>);
6287									impl<'de> Deserialize<'de> for DeserializeWith {
6288										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6289										where
6290											D: Deserializer<'de>,
6291										{
6292											Ok(DeserializeWith(serde_with::As::<
6293												serde_with::OneOrMany<serde_with::Same>,
6294											>::deserialize(deserializer)?))
6295										}
6296									}
6297									match map.next_value::<DeserializeWith>() {
6298										Ok(deserialize_with) => deserialize_with.0,
6299										Err(err) => {
6300											return Err(err);
6301										}
6302									}
6303								});
6304							}
6305							Field::ContentRating => {
6306								if r#content_rating_property.is_some() {
6307									return Err(<A::Error as de::Error>::duplicate_field(
6308										"contentRating",
6309									));
6310								}
6311								r#content_rating_property = Some({
6312									struct DeserializeWith(Vec<ContentRatingProperty>);
6313									impl<'de> Deserialize<'de> for DeserializeWith {
6314										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6315										where
6316											D: Deserializer<'de>,
6317										{
6318											Ok(DeserializeWith(serde_with::As::<
6319												serde_with::OneOrMany<serde_with::Same>,
6320											>::deserialize(deserializer)?))
6321										}
6322									}
6323									match map.next_value::<DeserializeWith>() {
6324										Ok(deserialize_with) => deserialize_with.0,
6325										Err(err) => {
6326											return Err(err);
6327										}
6328									}
6329								});
6330							}
6331							Field::ContentReferenceTime => {
6332								if r#content_reference_time_property.is_some() {
6333									return Err(<A::Error as de::Error>::duplicate_field(
6334										"contentReferenceTime",
6335									));
6336								}
6337								r#content_reference_time_property = Some({
6338									struct DeserializeWith(Vec<ContentReferenceTimeProperty>);
6339									impl<'de> Deserialize<'de> for DeserializeWith {
6340										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6341										where
6342											D: Deserializer<'de>,
6343										{
6344											Ok(DeserializeWith(serde_with::As::<
6345												serde_with::OneOrMany<serde_with::Same>,
6346											>::deserialize(deserializer)?))
6347										}
6348									}
6349									match map.next_value::<DeserializeWith>() {
6350										Ok(deserialize_with) => deserialize_with.0,
6351										Err(err) => {
6352											return Err(err);
6353										}
6354									}
6355								});
6356							}
6357							Field::Contributor => {
6358								if r#contributor_property.is_some() {
6359									return Err(<A::Error as de::Error>::duplicate_field(
6360										"contributor",
6361									));
6362								}
6363								r#contributor_property = Some({
6364									struct DeserializeWith(Vec<ContributorProperty>);
6365									impl<'de> Deserialize<'de> for DeserializeWith {
6366										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6367										where
6368											D: Deserializer<'de>,
6369										{
6370											Ok(DeserializeWith(serde_with::As::<
6371												serde_with::OneOrMany<serde_with::Same>,
6372											>::deserialize(deserializer)?))
6373										}
6374									}
6375									match map.next_value::<DeserializeWith>() {
6376										Ok(deserialize_with) => deserialize_with.0,
6377										Err(err) => {
6378											return Err(err);
6379										}
6380									}
6381								});
6382							}
6383							Field::CopyrightHolder => {
6384								if r#copyright_holder_property.is_some() {
6385									return Err(<A::Error as de::Error>::duplicate_field(
6386										"copyrightHolder",
6387									));
6388								}
6389								r#copyright_holder_property = Some({
6390									struct DeserializeWith(Vec<CopyrightHolderProperty>);
6391									impl<'de> Deserialize<'de> for DeserializeWith {
6392										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6393										where
6394											D: Deserializer<'de>,
6395										{
6396											Ok(DeserializeWith(serde_with::As::<
6397												serde_with::OneOrMany<serde_with::Same>,
6398											>::deserialize(deserializer)?))
6399										}
6400									}
6401									match map.next_value::<DeserializeWith>() {
6402										Ok(deserialize_with) => deserialize_with.0,
6403										Err(err) => {
6404											return Err(err);
6405										}
6406									}
6407								});
6408							}
6409							Field::CopyrightNotice => {
6410								if r#copyright_notice_property.is_some() {
6411									return Err(<A::Error as de::Error>::duplicate_field(
6412										"copyrightNotice",
6413									));
6414								}
6415								r#copyright_notice_property = Some({
6416									struct DeserializeWith(Vec<CopyrightNoticeProperty>);
6417									impl<'de> Deserialize<'de> for DeserializeWith {
6418										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6419										where
6420											D: Deserializer<'de>,
6421										{
6422											Ok(DeserializeWith(serde_with::As::<
6423												serde_with::OneOrMany<serde_with::Same>,
6424											>::deserialize(deserializer)?))
6425										}
6426									}
6427									match map.next_value::<DeserializeWith>() {
6428										Ok(deserialize_with) => deserialize_with.0,
6429										Err(err) => {
6430											return Err(err);
6431										}
6432									}
6433								});
6434							}
6435							Field::CopyrightYear => {
6436								if r#copyright_year_property.is_some() {
6437									return Err(<A::Error as de::Error>::duplicate_field(
6438										"copyrightYear",
6439									));
6440								}
6441								r#copyright_year_property = Some({
6442									struct DeserializeWith(Vec<CopyrightYearProperty>);
6443									impl<'de> Deserialize<'de> for DeserializeWith {
6444										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6445										where
6446											D: Deserializer<'de>,
6447										{
6448											Ok(DeserializeWith(serde_with::As::<
6449												serde_with::OneOrMany<serde_with::Same>,
6450											>::deserialize(deserializer)?))
6451										}
6452									}
6453									match map.next_value::<DeserializeWith>() {
6454										Ok(deserialize_with) => deserialize_with.0,
6455										Err(err) => {
6456											return Err(err);
6457										}
6458									}
6459								});
6460							}
6461							Field::Correction => {
6462								if r#correction_property.is_some() {
6463									return Err(<A::Error as de::Error>::duplicate_field(
6464										"correction",
6465									));
6466								}
6467								r#correction_property = Some({
6468									struct DeserializeWith(Vec<CorrectionProperty>);
6469									impl<'de> Deserialize<'de> for DeserializeWith {
6470										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6471										where
6472											D: Deserializer<'de>,
6473										{
6474											Ok(DeserializeWith(serde_with::As::<
6475												serde_with::OneOrMany<serde_with::Same>,
6476											>::deserialize(deserializer)?))
6477										}
6478									}
6479									match map.next_value::<DeserializeWith>() {
6480										Ok(deserialize_with) => deserialize_with.0,
6481										Err(err) => {
6482											return Err(err);
6483										}
6484									}
6485								});
6486							}
6487							Field::CountryOfOrigin => {
6488								if r#country_of_origin_property.is_some() {
6489									return Err(<A::Error as de::Error>::duplicate_field(
6490										"countryOfOrigin",
6491									));
6492								}
6493								r#country_of_origin_property = Some({
6494									struct DeserializeWith(Vec<CountryOfOriginProperty>);
6495									impl<'de> Deserialize<'de> for DeserializeWith {
6496										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6497										where
6498											D: Deserializer<'de>,
6499										{
6500											Ok(DeserializeWith(serde_with::As::<
6501												serde_with::OneOrMany<serde_with::Same>,
6502											>::deserialize(deserializer)?))
6503										}
6504									}
6505									match map.next_value::<DeserializeWith>() {
6506										Ok(deserialize_with) => deserialize_with.0,
6507										Err(err) => {
6508											return Err(err);
6509										}
6510									}
6511								});
6512							}
6513							Field::CreativeWorkStatus => {
6514								if r#creative_work_status_property.is_some() {
6515									return Err(<A::Error as de::Error>::duplicate_field(
6516										"creativeWorkStatus",
6517									));
6518								}
6519								r#creative_work_status_property = Some({
6520									struct DeserializeWith(Vec<CreativeWorkStatusProperty>);
6521									impl<'de> Deserialize<'de> for DeserializeWith {
6522										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6523										where
6524											D: Deserializer<'de>,
6525										{
6526											Ok(DeserializeWith(serde_with::As::<
6527												serde_with::OneOrMany<serde_with::Same>,
6528											>::deserialize(deserializer)?))
6529										}
6530									}
6531									match map.next_value::<DeserializeWith>() {
6532										Ok(deserialize_with) => deserialize_with.0,
6533										Err(err) => {
6534											return Err(err);
6535										}
6536									}
6537								});
6538							}
6539							Field::Creator => {
6540								if r#creator_property.is_some() {
6541									return Err(<A::Error as de::Error>::duplicate_field(
6542										"creator",
6543									));
6544								}
6545								r#creator_property = Some({
6546									struct DeserializeWith(Vec<CreatorProperty>);
6547									impl<'de> Deserialize<'de> for DeserializeWith {
6548										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6549										where
6550											D: Deserializer<'de>,
6551										{
6552											Ok(DeserializeWith(serde_with::As::<
6553												serde_with::OneOrMany<serde_with::Same>,
6554											>::deserialize(deserializer)?))
6555										}
6556									}
6557									match map.next_value::<DeserializeWith>() {
6558										Ok(deserialize_with) => deserialize_with.0,
6559										Err(err) => {
6560											return Err(err);
6561										}
6562									}
6563								});
6564							}
6565							Field::CreditText => {
6566								if r#credit_text_property.is_some() {
6567									return Err(<A::Error as de::Error>::duplicate_field(
6568										"creditText",
6569									));
6570								}
6571								r#credit_text_property = Some({
6572									struct DeserializeWith(Vec<CreditTextProperty>);
6573									impl<'de> Deserialize<'de> for DeserializeWith {
6574										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6575										where
6576											D: Deserializer<'de>,
6577										{
6578											Ok(DeserializeWith(serde_with::As::<
6579												serde_with::OneOrMany<serde_with::Same>,
6580											>::deserialize(deserializer)?))
6581										}
6582									}
6583									match map.next_value::<DeserializeWith>() {
6584										Ok(deserialize_with) => deserialize_with.0,
6585										Err(err) => {
6586											return Err(err);
6587										}
6588									}
6589								});
6590							}
6591							Field::DateCreated => {
6592								if r#date_created_property.is_some() {
6593									return Err(<A::Error as de::Error>::duplicate_field(
6594										"dateCreated",
6595									));
6596								}
6597								r#date_created_property = Some({
6598									struct DeserializeWith(Vec<DateCreatedProperty>);
6599									impl<'de> Deserialize<'de> for DeserializeWith {
6600										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6601										where
6602											D: Deserializer<'de>,
6603										{
6604											Ok(DeserializeWith(serde_with::As::<
6605												serde_with::OneOrMany<serde_with::Same>,
6606											>::deserialize(deserializer)?))
6607										}
6608									}
6609									match map.next_value::<DeserializeWith>() {
6610										Ok(deserialize_with) => deserialize_with.0,
6611										Err(err) => {
6612											return Err(err);
6613										}
6614									}
6615								});
6616							}
6617							Field::DateModified => {
6618								if r#date_modified_property.is_some() {
6619									return Err(<A::Error as de::Error>::duplicate_field(
6620										"dateModified",
6621									));
6622								}
6623								r#date_modified_property = Some({
6624									struct DeserializeWith(Vec<DateModifiedProperty>);
6625									impl<'de> Deserialize<'de> for DeserializeWith {
6626										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6627										where
6628											D: Deserializer<'de>,
6629										{
6630											Ok(DeserializeWith(serde_with::As::<
6631												serde_with::OneOrMany<serde_with::Same>,
6632											>::deserialize(deserializer)?))
6633										}
6634									}
6635									match map.next_value::<DeserializeWith>() {
6636										Ok(deserialize_with) => deserialize_with.0,
6637										Err(err) => {
6638											return Err(err);
6639										}
6640									}
6641								});
6642							}
6643							Field::DatePublished => {
6644								if r#date_published_property.is_some() {
6645									return Err(<A::Error as de::Error>::duplicate_field(
6646										"datePublished",
6647									));
6648								}
6649								r#date_published_property = Some({
6650									struct DeserializeWith(Vec<DatePublishedProperty>);
6651									impl<'de> Deserialize<'de> for DeserializeWith {
6652										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6653										where
6654											D: Deserializer<'de>,
6655										{
6656											Ok(DeserializeWith(serde_with::As::<
6657												serde_with::OneOrMany<serde_with::Same>,
6658											>::deserialize(deserializer)?))
6659										}
6660									}
6661									match map.next_value::<DeserializeWith>() {
6662										Ok(deserialize_with) => deserialize_with.0,
6663										Err(err) => {
6664											return Err(err);
6665										}
6666									}
6667								});
6668							}
6669							Field::DiscussionUrl => {
6670								if r#discussion_url_property.is_some() {
6671									return Err(<A::Error as de::Error>::duplicate_field(
6672										"discussionUrl",
6673									));
6674								}
6675								r#discussion_url_property = Some({
6676									struct DeserializeWith(Vec<DiscussionUrlProperty>);
6677									impl<'de> Deserialize<'de> for DeserializeWith {
6678										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6679										where
6680											D: Deserializer<'de>,
6681										{
6682											Ok(DeserializeWith(serde_with::As::<
6683												serde_with::OneOrMany<serde_with::Same>,
6684											>::deserialize(deserializer)?))
6685										}
6686									}
6687									match map.next_value::<DeserializeWith>() {
6688										Ok(deserialize_with) => deserialize_with.0,
6689										Err(err) => {
6690											return Err(err);
6691										}
6692									}
6693								});
6694							}
6695							Field::EditEidr => {
6696								if r#edit_eidr_property.is_some() {
6697									return Err(<A::Error as de::Error>::duplicate_field(
6698										"editEIDR",
6699									));
6700								}
6701								r#edit_eidr_property = Some({
6702									struct DeserializeWith(Vec<EditEidrProperty>);
6703									impl<'de> Deserialize<'de> for DeserializeWith {
6704										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6705										where
6706											D: Deserializer<'de>,
6707										{
6708											Ok(DeserializeWith(serde_with::As::<
6709												serde_with::OneOrMany<serde_with::Same>,
6710											>::deserialize(deserializer)?))
6711										}
6712									}
6713									match map.next_value::<DeserializeWith>() {
6714										Ok(deserialize_with) => deserialize_with.0,
6715										Err(err) => {
6716											return Err(err);
6717										}
6718									}
6719								});
6720							}
6721							Field::Editor => {
6722								if r#editor_property.is_some() {
6723									return Err(<A::Error as de::Error>::duplicate_field("editor"));
6724								}
6725								r#editor_property = Some({
6726									struct DeserializeWith(Vec<EditorProperty>);
6727									impl<'de> Deserialize<'de> for DeserializeWith {
6728										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6729										where
6730											D: Deserializer<'de>,
6731										{
6732											Ok(DeserializeWith(serde_with::As::<
6733												serde_with::OneOrMany<serde_with::Same>,
6734											>::deserialize(deserializer)?))
6735										}
6736									}
6737									match map.next_value::<DeserializeWith>() {
6738										Ok(deserialize_with) => deserialize_with.0,
6739										Err(err) => {
6740											return Err(err);
6741										}
6742									}
6743								});
6744							}
6745							Field::EducationalAlignment => {
6746								if r#educational_alignment_property.is_some() {
6747									return Err(<A::Error as de::Error>::duplicate_field(
6748										"educationalAlignment",
6749									));
6750								}
6751								r#educational_alignment_property = Some({
6752									struct DeserializeWith(Vec<EducationalAlignmentProperty>);
6753									impl<'de> Deserialize<'de> for DeserializeWith {
6754										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6755										where
6756											D: Deserializer<'de>,
6757										{
6758											Ok(DeserializeWith(serde_with::As::<
6759												serde_with::OneOrMany<serde_with::Same>,
6760											>::deserialize(deserializer)?))
6761										}
6762									}
6763									match map.next_value::<DeserializeWith>() {
6764										Ok(deserialize_with) => deserialize_with.0,
6765										Err(err) => {
6766											return Err(err);
6767										}
6768									}
6769								});
6770							}
6771							Field::EducationalLevel => {
6772								if r#educational_level_property.is_some() {
6773									return Err(<A::Error as de::Error>::duplicate_field(
6774										"educationalLevel",
6775									));
6776								}
6777								r#educational_level_property = Some({
6778									struct DeserializeWith(Vec<EducationalLevelProperty>);
6779									impl<'de> Deserialize<'de> for DeserializeWith {
6780										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6781										where
6782											D: Deserializer<'de>,
6783										{
6784											Ok(DeserializeWith(serde_with::As::<
6785												serde_with::OneOrMany<serde_with::Same>,
6786											>::deserialize(deserializer)?))
6787										}
6788									}
6789									match map.next_value::<DeserializeWith>() {
6790										Ok(deserialize_with) => deserialize_with.0,
6791										Err(err) => {
6792											return Err(err);
6793										}
6794									}
6795								});
6796							}
6797							Field::EducationalUse => {
6798								if r#educational_use_property.is_some() {
6799									return Err(<A::Error as de::Error>::duplicate_field(
6800										"educationalUse",
6801									));
6802								}
6803								r#educational_use_property = Some({
6804									struct DeserializeWith(Vec<EducationalUseProperty>);
6805									impl<'de> Deserialize<'de> for DeserializeWith {
6806										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6807										where
6808											D: Deserializer<'de>,
6809										{
6810											Ok(DeserializeWith(serde_with::As::<
6811												serde_with::OneOrMany<serde_with::Same>,
6812											>::deserialize(deserializer)?))
6813										}
6814									}
6815									match map.next_value::<DeserializeWith>() {
6816										Ok(deserialize_with) => deserialize_with.0,
6817										Err(err) => {
6818											return Err(err);
6819										}
6820									}
6821								});
6822							}
6823							Field::Encoding => {
6824								if r#encoding_property.is_some() {
6825									return Err(<A::Error as de::Error>::duplicate_field(
6826										"encoding",
6827									));
6828								}
6829								r#encoding_property = Some({
6830									struct DeserializeWith(Vec<EncodingProperty>);
6831									impl<'de> Deserialize<'de> for DeserializeWith {
6832										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6833										where
6834											D: Deserializer<'de>,
6835										{
6836											Ok(DeserializeWith(serde_with::As::<
6837												serde_with::OneOrMany<serde_with::Same>,
6838											>::deserialize(deserializer)?))
6839										}
6840									}
6841									match map.next_value::<DeserializeWith>() {
6842										Ok(deserialize_with) => deserialize_with.0,
6843										Err(err) => {
6844											return Err(err);
6845										}
6846									}
6847								});
6848							}
6849							Field::EncodingFormat => {
6850								if r#encoding_format_property.is_some() {
6851									return Err(<A::Error as de::Error>::duplicate_field(
6852										"encodingFormat",
6853									));
6854								}
6855								r#encoding_format_property = Some({
6856									struct DeserializeWith(Vec<EncodingFormatProperty>);
6857									impl<'de> Deserialize<'de> for DeserializeWith {
6858										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6859										where
6860											D: Deserializer<'de>,
6861										{
6862											Ok(DeserializeWith(serde_with::As::<
6863												serde_with::OneOrMany<serde_with::Same>,
6864											>::deserialize(deserializer)?))
6865										}
6866									}
6867									match map.next_value::<DeserializeWith>() {
6868										Ok(deserialize_with) => deserialize_with.0,
6869										Err(err) => {
6870											return Err(err);
6871										}
6872									}
6873								});
6874							}
6875							Field::Encodings => {
6876								if r#encodings_property.is_some() {
6877									return Err(<A::Error as de::Error>::duplicate_field(
6878										"encodings",
6879									));
6880								}
6881								r#encodings_property = Some({
6882									struct DeserializeWith(Vec<EncodingsProperty>);
6883									impl<'de> Deserialize<'de> for DeserializeWith {
6884										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6885										where
6886											D: Deserializer<'de>,
6887										{
6888											Ok(DeserializeWith(serde_with::As::<
6889												serde_with::OneOrMany<serde_with::Same>,
6890											>::deserialize(deserializer)?))
6891										}
6892									}
6893									match map.next_value::<DeserializeWith>() {
6894										Ok(deserialize_with) => deserialize_with.0,
6895										Err(err) => {
6896											return Err(err);
6897										}
6898									}
6899								});
6900							}
6901							Field::ExampleOfWork => {
6902								if r#example_of_work_property.is_some() {
6903									return Err(<A::Error as de::Error>::duplicate_field(
6904										"exampleOfWork",
6905									));
6906								}
6907								r#example_of_work_property = Some({
6908									struct DeserializeWith(Vec<ExampleOfWorkProperty>);
6909									impl<'de> Deserialize<'de> for DeserializeWith {
6910										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6911										where
6912											D: Deserializer<'de>,
6913										{
6914											Ok(DeserializeWith(serde_with::As::<
6915												serde_with::OneOrMany<serde_with::Same>,
6916											>::deserialize(deserializer)?))
6917										}
6918									}
6919									match map.next_value::<DeserializeWith>() {
6920										Ok(deserialize_with) => deserialize_with.0,
6921										Err(err) => {
6922											return Err(err);
6923										}
6924									}
6925								});
6926							}
6927							Field::Expires => {
6928								if r#expires_property.is_some() {
6929									return Err(<A::Error as de::Error>::duplicate_field(
6930										"expires",
6931									));
6932								}
6933								r#expires_property = Some({
6934									struct DeserializeWith(Vec<ExpiresProperty>);
6935									impl<'de> Deserialize<'de> for DeserializeWith {
6936										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6937										where
6938											D: Deserializer<'de>,
6939										{
6940											Ok(DeserializeWith(serde_with::As::<
6941												serde_with::OneOrMany<serde_with::Same>,
6942											>::deserialize(deserializer)?))
6943										}
6944									}
6945									match map.next_value::<DeserializeWith>() {
6946										Ok(deserialize_with) => deserialize_with.0,
6947										Err(err) => {
6948											return Err(err);
6949										}
6950									}
6951								});
6952							}
6953							Field::FileFormat => {
6954								if r#file_format_property.is_some() {
6955									return Err(<A::Error as de::Error>::duplicate_field(
6956										"fileFormat",
6957									));
6958								}
6959								r#file_format_property = Some({
6960									struct DeserializeWith(Vec<FileFormatProperty>);
6961									impl<'de> Deserialize<'de> for DeserializeWith {
6962										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6963										where
6964											D: Deserializer<'de>,
6965										{
6966											Ok(DeserializeWith(serde_with::As::<
6967												serde_with::OneOrMany<serde_with::Same>,
6968											>::deserialize(deserializer)?))
6969										}
6970									}
6971									match map.next_value::<DeserializeWith>() {
6972										Ok(deserialize_with) => deserialize_with.0,
6973										Err(err) => {
6974											return Err(err);
6975										}
6976									}
6977								});
6978							}
6979							Field::Funder => {
6980								if r#funder_property.is_some() {
6981									return Err(<A::Error as de::Error>::duplicate_field("funder"));
6982								}
6983								r#funder_property = Some({
6984									struct DeserializeWith(Vec<FunderProperty>);
6985									impl<'de> Deserialize<'de> for DeserializeWith {
6986										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6987										where
6988											D: Deserializer<'de>,
6989										{
6990											Ok(DeserializeWith(serde_with::As::<
6991												serde_with::OneOrMany<serde_with::Same>,
6992											>::deserialize(deserializer)?))
6993										}
6994									}
6995									match map.next_value::<DeserializeWith>() {
6996										Ok(deserialize_with) => deserialize_with.0,
6997										Err(err) => {
6998											return Err(err);
6999										}
7000									}
7001								});
7002							}
7003							Field::Funding => {
7004								if r#funding_property.is_some() {
7005									return Err(<A::Error as de::Error>::duplicate_field(
7006										"funding",
7007									));
7008								}
7009								r#funding_property = Some({
7010									struct DeserializeWith(Vec<FundingProperty>);
7011									impl<'de> Deserialize<'de> for DeserializeWith {
7012										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7013										where
7014											D: Deserializer<'de>,
7015										{
7016											Ok(DeserializeWith(serde_with::As::<
7017												serde_with::OneOrMany<serde_with::Same>,
7018											>::deserialize(deserializer)?))
7019										}
7020									}
7021									match map.next_value::<DeserializeWith>() {
7022										Ok(deserialize_with) => deserialize_with.0,
7023										Err(err) => {
7024											return Err(err);
7025										}
7026									}
7027								});
7028							}
7029							Field::Genre => {
7030								if r#genre_property.is_some() {
7031									return Err(<A::Error as de::Error>::duplicate_field("genre"));
7032								}
7033								r#genre_property = Some({
7034									struct DeserializeWith(Vec<GenreProperty>);
7035									impl<'de> Deserialize<'de> for DeserializeWith {
7036										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7037										where
7038											D: Deserializer<'de>,
7039										{
7040											Ok(DeserializeWith(serde_with::As::<
7041												serde_with::OneOrMany<serde_with::Same>,
7042											>::deserialize(deserializer)?))
7043										}
7044									}
7045									match map.next_value::<DeserializeWith>() {
7046										Ok(deserialize_with) => deserialize_with.0,
7047										Err(err) => {
7048											return Err(err);
7049										}
7050									}
7051								});
7052							}
7053							Field::HasPart => {
7054								if r#has_part_property.is_some() {
7055									return Err(<A::Error as de::Error>::duplicate_field(
7056										"hasPart",
7057									));
7058								}
7059								r#has_part_property = Some({
7060									struct DeserializeWith(Vec<HasPartProperty>);
7061									impl<'de> Deserialize<'de> for DeserializeWith {
7062										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7063										where
7064											D: Deserializer<'de>,
7065										{
7066											Ok(DeserializeWith(serde_with::As::<
7067												serde_with::OneOrMany<serde_with::Same>,
7068											>::deserialize(deserializer)?))
7069										}
7070									}
7071									match map.next_value::<DeserializeWith>() {
7072										Ok(deserialize_with) => deserialize_with.0,
7073										Err(err) => {
7074											return Err(err);
7075										}
7076									}
7077								});
7078							}
7079							Field::Headline => {
7080								if r#headline_property.is_some() {
7081									return Err(<A::Error as de::Error>::duplicate_field(
7082										"headline",
7083									));
7084								}
7085								r#headline_property = Some({
7086									struct DeserializeWith(Vec<HeadlineProperty>);
7087									impl<'de> Deserialize<'de> for DeserializeWith {
7088										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7089										where
7090											D: Deserializer<'de>,
7091										{
7092											Ok(DeserializeWith(serde_with::As::<
7093												serde_with::OneOrMany<serde_with::Same>,
7094											>::deserialize(deserializer)?))
7095										}
7096									}
7097									match map.next_value::<DeserializeWith>() {
7098										Ok(deserialize_with) => deserialize_with.0,
7099										Err(err) => {
7100											return Err(err);
7101										}
7102									}
7103								});
7104							}
7105							Field::InLanguage => {
7106								if r#in_language_property.is_some() {
7107									return Err(<A::Error as de::Error>::duplicate_field(
7108										"inLanguage",
7109									));
7110								}
7111								r#in_language_property = Some({
7112									struct DeserializeWith(Vec<InLanguageProperty>);
7113									impl<'de> Deserialize<'de> for DeserializeWith {
7114										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7115										where
7116											D: Deserializer<'de>,
7117										{
7118											Ok(DeserializeWith(serde_with::As::<
7119												serde_with::OneOrMany<serde_with::Same>,
7120											>::deserialize(deserializer)?))
7121										}
7122									}
7123									match map.next_value::<DeserializeWith>() {
7124										Ok(deserialize_with) => deserialize_with.0,
7125										Err(err) => {
7126											return Err(err);
7127										}
7128									}
7129								});
7130							}
7131							Field::InteractionStatistic => {
7132								if r#interaction_statistic_property.is_some() {
7133									return Err(<A::Error as de::Error>::duplicate_field(
7134										"interactionStatistic",
7135									));
7136								}
7137								r#interaction_statistic_property = Some({
7138									struct DeserializeWith(Vec<InteractionStatisticProperty>);
7139									impl<'de> Deserialize<'de> for DeserializeWith {
7140										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7141										where
7142											D: Deserializer<'de>,
7143										{
7144											Ok(DeserializeWith(serde_with::As::<
7145												serde_with::OneOrMany<serde_with::Same>,
7146											>::deserialize(deserializer)?))
7147										}
7148									}
7149									match map.next_value::<DeserializeWith>() {
7150										Ok(deserialize_with) => deserialize_with.0,
7151										Err(err) => {
7152											return Err(err);
7153										}
7154									}
7155								});
7156							}
7157							Field::InteractivityType => {
7158								if r#interactivity_type_property.is_some() {
7159									return Err(<A::Error as de::Error>::duplicate_field(
7160										"interactivityType",
7161									));
7162								}
7163								r#interactivity_type_property = Some({
7164									struct DeserializeWith(Vec<InteractivityTypeProperty>);
7165									impl<'de> Deserialize<'de> for DeserializeWith {
7166										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7167										where
7168											D: Deserializer<'de>,
7169										{
7170											Ok(DeserializeWith(serde_with::As::<
7171												serde_with::OneOrMany<serde_with::Same>,
7172											>::deserialize(deserializer)?))
7173										}
7174									}
7175									match map.next_value::<DeserializeWith>() {
7176										Ok(deserialize_with) => deserialize_with.0,
7177										Err(err) => {
7178											return Err(err);
7179										}
7180									}
7181								});
7182							}
7183							Field::InterpretedAsClaim => {
7184								if r#interpreted_as_claim_property.is_some() {
7185									return Err(<A::Error as de::Error>::duplicate_field(
7186										"interpretedAsClaim",
7187									));
7188								}
7189								r#interpreted_as_claim_property = Some({
7190									struct DeserializeWith(Vec<InterpretedAsClaimProperty>);
7191									impl<'de> Deserialize<'de> for DeserializeWith {
7192										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7193										where
7194											D: Deserializer<'de>,
7195										{
7196											Ok(DeserializeWith(serde_with::As::<
7197												serde_with::OneOrMany<serde_with::Same>,
7198											>::deserialize(deserializer)?))
7199										}
7200									}
7201									match map.next_value::<DeserializeWith>() {
7202										Ok(deserialize_with) => deserialize_with.0,
7203										Err(err) => {
7204											return Err(err);
7205										}
7206									}
7207								});
7208							}
7209							Field::IsAccessibleForFree => {
7210								if r#is_accessible_for_free_property.is_some() {
7211									return Err(<A::Error as de::Error>::duplicate_field(
7212										"isAccessibleForFree",
7213									));
7214								}
7215								r#is_accessible_for_free_property = Some({
7216									struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
7217									impl<'de> Deserialize<'de> for DeserializeWith {
7218										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7219										where
7220											D: Deserializer<'de>,
7221										{
7222											Ok(DeserializeWith(serde_with::As::<
7223												serde_with::OneOrMany<serde_with::Same>,
7224											>::deserialize(deserializer)?))
7225										}
7226									}
7227									match map.next_value::<DeserializeWith>() {
7228										Ok(deserialize_with) => deserialize_with.0,
7229										Err(err) => {
7230											return Err(err);
7231										}
7232									}
7233								});
7234							}
7235							Field::IsBasedOn => {
7236								if r#is_based_on_property.is_some() {
7237									return Err(<A::Error as de::Error>::duplicate_field(
7238										"isBasedOn",
7239									));
7240								}
7241								r#is_based_on_property = Some({
7242									struct DeserializeWith(Vec<IsBasedOnProperty>);
7243									impl<'de> Deserialize<'de> for DeserializeWith {
7244										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7245										where
7246											D: Deserializer<'de>,
7247										{
7248											Ok(DeserializeWith(serde_with::As::<
7249												serde_with::OneOrMany<serde_with::Same>,
7250											>::deserialize(deserializer)?))
7251										}
7252									}
7253									match map.next_value::<DeserializeWith>() {
7254										Ok(deserialize_with) => deserialize_with.0,
7255										Err(err) => {
7256											return Err(err);
7257										}
7258									}
7259								});
7260							}
7261							Field::IsBasedOnUrl => {
7262								if r#is_based_on_url_property.is_some() {
7263									return Err(<A::Error as de::Error>::duplicate_field(
7264										"isBasedOnUrl",
7265									));
7266								}
7267								r#is_based_on_url_property = Some({
7268									struct DeserializeWith(Vec<IsBasedOnUrlProperty>);
7269									impl<'de> Deserialize<'de> for DeserializeWith {
7270										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7271										where
7272											D: Deserializer<'de>,
7273										{
7274											Ok(DeserializeWith(serde_with::As::<
7275												serde_with::OneOrMany<serde_with::Same>,
7276											>::deserialize(deserializer)?))
7277										}
7278									}
7279									match map.next_value::<DeserializeWith>() {
7280										Ok(deserialize_with) => deserialize_with.0,
7281										Err(err) => {
7282											return Err(err);
7283										}
7284									}
7285								});
7286							}
7287							Field::IsFamilyFriendly => {
7288								if r#is_family_friendly_property.is_some() {
7289									return Err(<A::Error as de::Error>::duplicate_field(
7290										"isFamilyFriendly",
7291									));
7292								}
7293								r#is_family_friendly_property = Some({
7294									struct DeserializeWith(Vec<IsFamilyFriendlyProperty>);
7295									impl<'de> Deserialize<'de> for DeserializeWith {
7296										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7297										where
7298											D: Deserializer<'de>,
7299										{
7300											Ok(DeserializeWith(serde_with::As::<
7301												serde_with::OneOrMany<serde_with::Same>,
7302											>::deserialize(deserializer)?))
7303										}
7304									}
7305									match map.next_value::<DeserializeWith>() {
7306										Ok(deserialize_with) => deserialize_with.0,
7307										Err(err) => {
7308											return Err(err);
7309										}
7310									}
7311								});
7312							}
7313							Field::IsPartOf => {
7314								if r#is_part_of_property.is_some() {
7315									return Err(<A::Error as de::Error>::duplicate_field(
7316										"isPartOf",
7317									));
7318								}
7319								r#is_part_of_property = Some({
7320									struct DeserializeWith(Vec<IsPartOfProperty>);
7321									impl<'de> Deserialize<'de> for DeserializeWith {
7322										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7323										where
7324											D: Deserializer<'de>,
7325										{
7326											Ok(DeserializeWith(serde_with::As::<
7327												serde_with::OneOrMany<serde_with::Same>,
7328											>::deserialize(deserializer)?))
7329										}
7330									}
7331									match map.next_value::<DeserializeWith>() {
7332										Ok(deserialize_with) => deserialize_with.0,
7333										Err(err) => {
7334											return Err(err);
7335										}
7336									}
7337								});
7338							}
7339							Field::Keywords => {
7340								if r#keywords_property.is_some() {
7341									return Err(<A::Error as de::Error>::duplicate_field(
7342										"keywords",
7343									));
7344								}
7345								r#keywords_property = Some({
7346									struct DeserializeWith(Vec<KeywordsProperty>);
7347									impl<'de> Deserialize<'de> for DeserializeWith {
7348										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7349										where
7350											D: Deserializer<'de>,
7351										{
7352											Ok(DeserializeWith(serde_with::As::<
7353												serde_with::OneOrMany<serde_with::Same>,
7354											>::deserialize(deserializer)?))
7355										}
7356									}
7357									match map.next_value::<DeserializeWith>() {
7358										Ok(deserialize_with) => deserialize_with.0,
7359										Err(err) => {
7360											return Err(err);
7361										}
7362									}
7363								});
7364							}
7365							Field::LearningResourceType => {
7366								if r#learning_resource_type_property.is_some() {
7367									return Err(<A::Error as de::Error>::duplicate_field(
7368										"learningResourceType",
7369									));
7370								}
7371								r#learning_resource_type_property = Some({
7372									struct DeserializeWith(Vec<LearningResourceTypeProperty>);
7373									impl<'de> Deserialize<'de> for DeserializeWith {
7374										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7375										where
7376											D: Deserializer<'de>,
7377										{
7378											Ok(DeserializeWith(serde_with::As::<
7379												serde_with::OneOrMany<serde_with::Same>,
7380											>::deserialize(deserializer)?))
7381										}
7382									}
7383									match map.next_value::<DeserializeWith>() {
7384										Ok(deserialize_with) => deserialize_with.0,
7385										Err(err) => {
7386											return Err(err);
7387										}
7388									}
7389								});
7390							}
7391							Field::License => {
7392								if r#license_property.is_some() {
7393									return Err(<A::Error as de::Error>::duplicate_field(
7394										"license",
7395									));
7396								}
7397								r#license_property = Some({
7398									struct DeserializeWith(Vec<LicenseProperty>);
7399									impl<'de> Deserialize<'de> for DeserializeWith {
7400										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7401										where
7402											D: Deserializer<'de>,
7403										{
7404											Ok(DeserializeWith(serde_with::As::<
7405												serde_with::OneOrMany<serde_with::Same>,
7406											>::deserialize(deserializer)?))
7407										}
7408									}
7409									match map.next_value::<DeserializeWith>() {
7410										Ok(deserialize_with) => deserialize_with.0,
7411										Err(err) => {
7412											return Err(err);
7413										}
7414									}
7415								});
7416							}
7417							Field::LocationCreated => {
7418								if r#location_created_property.is_some() {
7419									return Err(<A::Error as de::Error>::duplicate_field(
7420										"locationCreated",
7421									));
7422								}
7423								r#location_created_property = Some({
7424									struct DeserializeWith(Vec<LocationCreatedProperty>);
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::MainEntity => {
7444								if r#main_entity_property.is_some() {
7445									return Err(<A::Error as de::Error>::duplicate_field(
7446										"mainEntity",
7447									));
7448								}
7449								r#main_entity_property = Some({
7450									struct DeserializeWith(Vec<MainEntityProperty>);
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::Maintainer => {
7470								if r#maintainer_property.is_some() {
7471									return Err(<A::Error as de::Error>::duplicate_field(
7472										"maintainer",
7473									));
7474								}
7475								r#maintainer_property = Some({
7476									struct DeserializeWith(Vec<MaintainerProperty>);
7477									impl<'de> Deserialize<'de> for DeserializeWith {
7478										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7479										where
7480											D: Deserializer<'de>,
7481										{
7482											Ok(DeserializeWith(serde_with::As::<
7483												serde_with::OneOrMany<serde_with::Same>,
7484											>::deserialize(deserializer)?))
7485										}
7486									}
7487									match map.next_value::<DeserializeWith>() {
7488										Ok(deserialize_with) => deserialize_with.0,
7489										Err(err) => {
7490											return Err(err);
7491										}
7492									}
7493								});
7494							}
7495							Field::Material => {
7496								if r#material_property.is_some() {
7497									return Err(<A::Error as de::Error>::duplicate_field(
7498										"material",
7499									));
7500								}
7501								r#material_property = Some({
7502									struct DeserializeWith(Vec<MaterialProperty>);
7503									impl<'de> Deserialize<'de> for DeserializeWith {
7504										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7505										where
7506											D: Deserializer<'de>,
7507										{
7508											Ok(DeserializeWith(serde_with::As::<
7509												serde_with::OneOrMany<serde_with::Same>,
7510											>::deserialize(deserializer)?))
7511										}
7512									}
7513									match map.next_value::<DeserializeWith>() {
7514										Ok(deserialize_with) => deserialize_with.0,
7515										Err(err) => {
7516											return Err(err);
7517										}
7518									}
7519								});
7520							}
7521							Field::MaterialExtent => {
7522								if r#material_extent_property.is_some() {
7523									return Err(<A::Error as de::Error>::duplicate_field(
7524										"materialExtent",
7525									));
7526								}
7527								r#material_extent_property = Some({
7528									struct DeserializeWith(Vec<MaterialExtentProperty>);
7529									impl<'de> Deserialize<'de> for DeserializeWith {
7530										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7531										where
7532											D: Deserializer<'de>,
7533										{
7534											Ok(DeserializeWith(serde_with::As::<
7535												serde_with::OneOrMany<serde_with::Same>,
7536											>::deserialize(deserializer)?))
7537										}
7538									}
7539									match map.next_value::<DeserializeWith>() {
7540										Ok(deserialize_with) => deserialize_with.0,
7541										Err(err) => {
7542											return Err(err);
7543										}
7544									}
7545								});
7546							}
7547							Field::Mentions => {
7548								if r#mentions_property.is_some() {
7549									return Err(<A::Error as de::Error>::duplicate_field(
7550										"mentions",
7551									));
7552								}
7553								r#mentions_property = Some({
7554									struct DeserializeWith(Vec<MentionsProperty>);
7555									impl<'de> Deserialize<'de> for DeserializeWith {
7556										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7557										where
7558											D: Deserializer<'de>,
7559										{
7560											Ok(DeserializeWith(serde_with::As::<
7561												serde_with::OneOrMany<serde_with::Same>,
7562											>::deserialize(deserializer)?))
7563										}
7564									}
7565									match map.next_value::<DeserializeWith>() {
7566										Ok(deserialize_with) => deserialize_with.0,
7567										Err(err) => {
7568											return Err(err);
7569										}
7570									}
7571								});
7572							}
7573							Field::Offers => {
7574								if r#offers_property.is_some() {
7575									return Err(<A::Error as de::Error>::duplicate_field("offers"));
7576								}
7577								r#offers_property = Some({
7578									struct DeserializeWith(Vec<OffersProperty>);
7579									impl<'de> Deserialize<'de> for DeserializeWith {
7580										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7581										where
7582											D: Deserializer<'de>,
7583										{
7584											Ok(DeserializeWith(serde_with::As::<
7585												serde_with::OneOrMany<serde_with::Same>,
7586											>::deserialize(deserializer)?))
7587										}
7588									}
7589									match map.next_value::<DeserializeWith>() {
7590										Ok(deserialize_with) => deserialize_with.0,
7591										Err(err) => {
7592											return Err(err);
7593										}
7594									}
7595								});
7596							}
7597							Field::Pattern => {
7598								if r#pattern_property.is_some() {
7599									return Err(<A::Error as de::Error>::duplicate_field(
7600										"pattern",
7601									));
7602								}
7603								r#pattern_property = Some({
7604									struct DeserializeWith(Vec<PatternProperty>);
7605									impl<'de> Deserialize<'de> for DeserializeWith {
7606										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7607										where
7608											D: Deserializer<'de>,
7609										{
7610											Ok(DeserializeWith(serde_with::As::<
7611												serde_with::OneOrMany<serde_with::Same>,
7612											>::deserialize(deserializer)?))
7613										}
7614									}
7615									match map.next_value::<DeserializeWith>() {
7616										Ok(deserialize_with) => deserialize_with.0,
7617										Err(err) => {
7618											return Err(err);
7619										}
7620									}
7621								});
7622							}
7623							Field::Position => {
7624								if r#position_property.is_some() {
7625									return Err(<A::Error as de::Error>::duplicate_field(
7626										"position",
7627									));
7628								}
7629								r#position_property = Some({
7630									struct DeserializeWith(Vec<PositionProperty>);
7631									impl<'de> Deserialize<'de> for DeserializeWith {
7632										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7633										where
7634											D: Deserializer<'de>,
7635										{
7636											Ok(DeserializeWith(serde_with::As::<
7637												serde_with::OneOrMany<serde_with::Same>,
7638											>::deserialize(deserializer)?))
7639										}
7640									}
7641									match map.next_value::<DeserializeWith>() {
7642										Ok(deserialize_with) => deserialize_with.0,
7643										Err(err) => {
7644											return Err(err);
7645										}
7646									}
7647								});
7648							}
7649							Field::Producer => {
7650								if r#producer_property.is_some() {
7651									return Err(<A::Error as de::Error>::duplicate_field(
7652										"producer",
7653									));
7654								}
7655								r#producer_property = Some({
7656									struct DeserializeWith(Vec<ProducerProperty>);
7657									impl<'de> Deserialize<'de> for DeserializeWith {
7658										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7659										where
7660											D: Deserializer<'de>,
7661										{
7662											Ok(DeserializeWith(serde_with::As::<
7663												serde_with::OneOrMany<serde_with::Same>,
7664											>::deserialize(deserializer)?))
7665										}
7666									}
7667									match map.next_value::<DeserializeWith>() {
7668										Ok(deserialize_with) => deserialize_with.0,
7669										Err(err) => {
7670											return Err(err);
7671										}
7672									}
7673								});
7674							}
7675							Field::Provider => {
7676								if r#provider_property.is_some() {
7677									return Err(<A::Error as de::Error>::duplicate_field(
7678										"provider",
7679									));
7680								}
7681								r#provider_property = Some({
7682									struct DeserializeWith(Vec<ProviderProperty>);
7683									impl<'de> Deserialize<'de> for DeserializeWith {
7684										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7685										where
7686											D: Deserializer<'de>,
7687										{
7688											Ok(DeserializeWith(serde_with::As::<
7689												serde_with::OneOrMany<serde_with::Same>,
7690											>::deserialize(deserializer)?))
7691										}
7692									}
7693									match map.next_value::<DeserializeWith>() {
7694										Ok(deserialize_with) => deserialize_with.0,
7695										Err(err) => {
7696											return Err(err);
7697										}
7698									}
7699								});
7700							}
7701							Field::Publication => {
7702								if r#publication_property.is_some() {
7703									return Err(<A::Error as de::Error>::duplicate_field(
7704										"publication",
7705									));
7706								}
7707								r#publication_property = Some({
7708									struct DeserializeWith(Vec<PublicationProperty>);
7709									impl<'de> Deserialize<'de> for DeserializeWith {
7710										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7711										where
7712											D: Deserializer<'de>,
7713										{
7714											Ok(DeserializeWith(serde_with::As::<
7715												serde_with::OneOrMany<serde_with::Same>,
7716											>::deserialize(deserializer)?))
7717										}
7718									}
7719									match map.next_value::<DeserializeWith>() {
7720										Ok(deserialize_with) => deserialize_with.0,
7721										Err(err) => {
7722											return Err(err);
7723										}
7724									}
7725								});
7726							}
7727							Field::Publisher => {
7728								if r#publisher_property.is_some() {
7729									return Err(<A::Error as de::Error>::duplicate_field(
7730										"publisher",
7731									));
7732								}
7733								r#publisher_property = Some({
7734									struct DeserializeWith(Vec<PublisherProperty>);
7735									impl<'de> Deserialize<'de> for DeserializeWith {
7736										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7737										where
7738											D: Deserializer<'de>,
7739										{
7740											Ok(DeserializeWith(serde_with::As::<
7741												serde_with::OneOrMany<serde_with::Same>,
7742											>::deserialize(deserializer)?))
7743										}
7744									}
7745									match map.next_value::<DeserializeWith>() {
7746										Ok(deserialize_with) => deserialize_with.0,
7747										Err(err) => {
7748											return Err(err);
7749										}
7750									}
7751								});
7752							}
7753							Field::PublisherImprint => {
7754								if r#publisher_imprint_property.is_some() {
7755									return Err(<A::Error as de::Error>::duplicate_field(
7756										"publisherImprint",
7757									));
7758								}
7759								r#publisher_imprint_property = Some({
7760									struct DeserializeWith(Vec<PublisherImprintProperty>);
7761									impl<'de> Deserialize<'de> for DeserializeWith {
7762										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7763										where
7764											D: Deserializer<'de>,
7765										{
7766											Ok(DeserializeWith(serde_with::As::<
7767												serde_with::OneOrMany<serde_with::Same>,
7768											>::deserialize(deserializer)?))
7769										}
7770									}
7771									match map.next_value::<DeserializeWith>() {
7772										Ok(deserialize_with) => deserialize_with.0,
7773										Err(err) => {
7774											return Err(err);
7775										}
7776									}
7777								});
7778							}
7779							Field::PublishingPrinciples => {
7780								if r#publishing_principles_property.is_some() {
7781									return Err(<A::Error as de::Error>::duplicate_field(
7782										"publishingPrinciples",
7783									));
7784								}
7785								r#publishing_principles_property = Some({
7786									struct DeserializeWith(Vec<PublishingPrinciplesProperty>);
7787									impl<'de> Deserialize<'de> for DeserializeWith {
7788										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7789										where
7790											D: Deserializer<'de>,
7791										{
7792											Ok(DeserializeWith(serde_with::As::<
7793												serde_with::OneOrMany<serde_with::Same>,
7794											>::deserialize(deserializer)?))
7795										}
7796									}
7797									match map.next_value::<DeserializeWith>() {
7798										Ok(deserialize_with) => deserialize_with.0,
7799										Err(err) => {
7800											return Err(err);
7801										}
7802									}
7803								});
7804							}
7805							Field::RecordedAt => {
7806								if r#recorded_at_property.is_some() {
7807									return Err(<A::Error as de::Error>::duplicate_field(
7808										"recordedAt",
7809									));
7810								}
7811								r#recorded_at_property = Some({
7812									struct DeserializeWith(Vec<RecordedAtProperty>);
7813									impl<'de> Deserialize<'de> for DeserializeWith {
7814										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7815										where
7816											D: Deserializer<'de>,
7817										{
7818											Ok(DeserializeWith(serde_with::As::<
7819												serde_with::OneOrMany<serde_with::Same>,
7820											>::deserialize(deserializer)?))
7821										}
7822									}
7823									match map.next_value::<DeserializeWith>() {
7824										Ok(deserialize_with) => deserialize_with.0,
7825										Err(err) => {
7826											return Err(err);
7827										}
7828									}
7829								});
7830							}
7831							Field::ReleasedEvent => {
7832								if r#released_event_property.is_some() {
7833									return Err(<A::Error as de::Error>::duplicate_field(
7834										"releasedEvent",
7835									));
7836								}
7837								r#released_event_property = Some({
7838									struct DeserializeWith(Vec<ReleasedEventProperty>);
7839									impl<'de> Deserialize<'de> for DeserializeWith {
7840										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7841										where
7842											D: Deserializer<'de>,
7843										{
7844											Ok(DeserializeWith(serde_with::As::<
7845												serde_with::OneOrMany<serde_with::Same>,
7846											>::deserialize(deserializer)?))
7847										}
7848									}
7849									match map.next_value::<DeserializeWith>() {
7850										Ok(deserialize_with) => deserialize_with.0,
7851										Err(err) => {
7852											return Err(err);
7853										}
7854									}
7855								});
7856							}
7857							Field::Review => {
7858								if r#review_property.is_some() {
7859									return Err(<A::Error as de::Error>::duplicate_field("review"));
7860								}
7861								r#review_property = Some({
7862									struct DeserializeWith(Vec<ReviewProperty>);
7863									impl<'de> Deserialize<'de> for DeserializeWith {
7864										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7865										where
7866											D: Deserializer<'de>,
7867										{
7868											Ok(DeserializeWith(serde_with::As::<
7869												serde_with::OneOrMany<serde_with::Same>,
7870											>::deserialize(deserializer)?))
7871										}
7872									}
7873									match map.next_value::<DeserializeWith>() {
7874										Ok(deserialize_with) => deserialize_with.0,
7875										Err(err) => {
7876											return Err(err);
7877										}
7878									}
7879								});
7880							}
7881							Field::Reviews => {
7882								if r#reviews_property.is_some() {
7883									return Err(<A::Error as de::Error>::duplicate_field(
7884										"reviews",
7885									));
7886								}
7887								r#reviews_property = Some({
7888									struct DeserializeWith(Vec<ReviewsProperty>);
7889									impl<'de> Deserialize<'de> for DeserializeWith {
7890										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7891										where
7892											D: Deserializer<'de>,
7893										{
7894											Ok(DeserializeWith(serde_with::As::<
7895												serde_with::OneOrMany<serde_with::Same>,
7896											>::deserialize(deserializer)?))
7897										}
7898									}
7899									match map.next_value::<DeserializeWith>() {
7900										Ok(deserialize_with) => deserialize_with.0,
7901										Err(err) => {
7902											return Err(err);
7903										}
7904									}
7905								});
7906							}
7907							Field::SchemaVersion => {
7908								if r#schema_version_property.is_some() {
7909									return Err(<A::Error as de::Error>::duplicate_field(
7910										"schemaVersion",
7911									));
7912								}
7913								r#schema_version_property = Some({
7914									struct DeserializeWith(Vec<SchemaVersionProperty>);
7915									impl<'de> Deserialize<'de> for DeserializeWith {
7916										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7917										where
7918											D: Deserializer<'de>,
7919										{
7920											Ok(DeserializeWith(serde_with::As::<
7921												serde_with::OneOrMany<serde_with::Same>,
7922											>::deserialize(deserializer)?))
7923										}
7924									}
7925									match map.next_value::<DeserializeWith>() {
7926										Ok(deserialize_with) => deserialize_with.0,
7927										Err(err) => {
7928											return Err(err);
7929										}
7930									}
7931								});
7932							}
7933							Field::SdDatePublished => {
7934								if r#sd_date_published_property.is_some() {
7935									return Err(<A::Error as de::Error>::duplicate_field(
7936										"sdDatePublished",
7937									));
7938								}
7939								r#sd_date_published_property = Some({
7940									struct DeserializeWith(Vec<SdDatePublishedProperty>);
7941									impl<'de> Deserialize<'de> for DeserializeWith {
7942										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7943										where
7944											D: Deserializer<'de>,
7945										{
7946											Ok(DeserializeWith(serde_with::As::<
7947												serde_with::OneOrMany<serde_with::Same>,
7948											>::deserialize(deserializer)?))
7949										}
7950									}
7951									match map.next_value::<DeserializeWith>() {
7952										Ok(deserialize_with) => deserialize_with.0,
7953										Err(err) => {
7954											return Err(err);
7955										}
7956									}
7957								});
7958							}
7959							Field::SdLicense => {
7960								if r#sd_license_property.is_some() {
7961									return Err(<A::Error as de::Error>::duplicate_field(
7962										"sdLicense",
7963									));
7964								}
7965								r#sd_license_property = Some({
7966									struct DeserializeWith(Vec<SdLicenseProperty>);
7967									impl<'de> Deserialize<'de> for DeserializeWith {
7968										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7969										where
7970											D: Deserializer<'de>,
7971										{
7972											Ok(DeserializeWith(serde_with::As::<
7973												serde_with::OneOrMany<serde_with::Same>,
7974											>::deserialize(deserializer)?))
7975										}
7976									}
7977									match map.next_value::<DeserializeWith>() {
7978										Ok(deserialize_with) => deserialize_with.0,
7979										Err(err) => {
7980											return Err(err);
7981										}
7982									}
7983								});
7984							}
7985							Field::SdPublisher => {
7986								if r#sd_publisher_property.is_some() {
7987									return Err(<A::Error as de::Error>::duplicate_field(
7988										"sdPublisher",
7989									));
7990								}
7991								r#sd_publisher_property = Some({
7992									struct DeserializeWith(Vec<SdPublisherProperty>);
7993									impl<'de> Deserialize<'de> for DeserializeWith {
7994										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7995										where
7996											D: Deserializer<'de>,
7997										{
7998											Ok(DeserializeWith(serde_with::As::<
7999												serde_with::OneOrMany<serde_with::Same>,
8000											>::deserialize(deserializer)?))
8001										}
8002									}
8003									match map.next_value::<DeserializeWith>() {
8004										Ok(deserialize_with) => deserialize_with.0,
8005										Err(err) => {
8006											return Err(err);
8007										}
8008									}
8009								});
8010							}
8011							Field::Size => {
8012								if r#size_property.is_some() {
8013									return Err(<A::Error as de::Error>::duplicate_field("size"));
8014								}
8015								r#size_property = Some({
8016									struct DeserializeWith(Vec<SizeProperty>);
8017									impl<'de> Deserialize<'de> for DeserializeWith {
8018										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8019										where
8020											D: Deserializer<'de>,
8021										{
8022											Ok(DeserializeWith(serde_with::As::<
8023												serde_with::OneOrMany<serde_with::Same>,
8024											>::deserialize(deserializer)?))
8025										}
8026									}
8027									match map.next_value::<DeserializeWith>() {
8028										Ok(deserialize_with) => deserialize_with.0,
8029										Err(err) => {
8030											return Err(err);
8031										}
8032									}
8033								});
8034							}
8035							Field::SourceOrganization => {
8036								if r#source_organization_property.is_some() {
8037									return Err(<A::Error as de::Error>::duplicate_field(
8038										"sourceOrganization",
8039									));
8040								}
8041								r#source_organization_property = Some({
8042									struct DeserializeWith(Vec<SourceOrganizationProperty>);
8043									impl<'de> Deserialize<'de> for DeserializeWith {
8044										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8045										where
8046											D: Deserializer<'de>,
8047										{
8048											Ok(DeserializeWith(serde_with::As::<
8049												serde_with::OneOrMany<serde_with::Same>,
8050											>::deserialize(deserializer)?))
8051										}
8052									}
8053									match map.next_value::<DeserializeWith>() {
8054										Ok(deserialize_with) => deserialize_with.0,
8055										Err(err) => {
8056											return Err(err);
8057										}
8058									}
8059								});
8060							}
8061							Field::Spatial => {
8062								if r#spatial_property.is_some() {
8063									return Err(<A::Error as de::Error>::duplicate_field(
8064										"spatial",
8065									));
8066								}
8067								r#spatial_property = Some({
8068									struct DeserializeWith(Vec<SpatialProperty>);
8069									impl<'de> Deserialize<'de> for DeserializeWith {
8070										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8071										where
8072											D: Deserializer<'de>,
8073										{
8074											Ok(DeserializeWith(serde_with::As::<
8075												serde_with::OneOrMany<serde_with::Same>,
8076											>::deserialize(deserializer)?))
8077										}
8078									}
8079									match map.next_value::<DeserializeWith>() {
8080										Ok(deserialize_with) => deserialize_with.0,
8081										Err(err) => {
8082											return Err(err);
8083										}
8084									}
8085								});
8086							}
8087							Field::SpatialCoverage => {
8088								if r#spatial_coverage_property.is_some() {
8089									return Err(<A::Error as de::Error>::duplicate_field(
8090										"spatialCoverage",
8091									));
8092								}
8093								r#spatial_coverage_property = Some({
8094									struct DeserializeWith(Vec<SpatialCoverageProperty>);
8095									impl<'de> Deserialize<'de> for DeserializeWith {
8096										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8097										where
8098											D: Deserializer<'de>,
8099										{
8100											Ok(DeserializeWith(serde_with::As::<
8101												serde_with::OneOrMany<serde_with::Same>,
8102											>::deserialize(deserializer)?))
8103										}
8104									}
8105									match map.next_value::<DeserializeWith>() {
8106										Ok(deserialize_with) => deserialize_with.0,
8107										Err(err) => {
8108											return Err(err);
8109										}
8110									}
8111								});
8112							}
8113							Field::Sponsor => {
8114								if r#sponsor_property.is_some() {
8115									return Err(<A::Error as de::Error>::duplicate_field(
8116										"sponsor",
8117									));
8118								}
8119								r#sponsor_property = Some({
8120									struct DeserializeWith(Vec<SponsorProperty>);
8121									impl<'de> Deserialize<'de> for DeserializeWith {
8122										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8123										where
8124											D: Deserializer<'de>,
8125										{
8126											Ok(DeserializeWith(serde_with::As::<
8127												serde_with::OneOrMany<serde_with::Same>,
8128											>::deserialize(deserializer)?))
8129										}
8130									}
8131									match map.next_value::<DeserializeWith>() {
8132										Ok(deserialize_with) => deserialize_with.0,
8133										Err(err) => {
8134											return Err(err);
8135										}
8136									}
8137								});
8138							}
8139							Field::Teaches => {
8140								if r#teaches_property.is_some() {
8141									return Err(<A::Error as de::Error>::duplicate_field(
8142										"teaches",
8143									));
8144								}
8145								r#teaches_property = Some({
8146									struct DeserializeWith(Vec<TeachesProperty>);
8147									impl<'de> Deserialize<'de> for DeserializeWith {
8148										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8149										where
8150											D: Deserializer<'de>,
8151										{
8152											Ok(DeserializeWith(serde_with::As::<
8153												serde_with::OneOrMany<serde_with::Same>,
8154											>::deserialize(deserializer)?))
8155										}
8156									}
8157									match map.next_value::<DeserializeWith>() {
8158										Ok(deserialize_with) => deserialize_with.0,
8159										Err(err) => {
8160											return Err(err);
8161										}
8162									}
8163								});
8164							}
8165							Field::Temporal => {
8166								if r#temporal_property.is_some() {
8167									return Err(<A::Error as de::Error>::duplicate_field(
8168										"temporal",
8169									));
8170								}
8171								r#temporal_property = Some({
8172									struct DeserializeWith(Vec<TemporalProperty>);
8173									impl<'de> Deserialize<'de> for DeserializeWith {
8174										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8175										where
8176											D: Deserializer<'de>,
8177										{
8178											Ok(DeserializeWith(serde_with::As::<
8179												serde_with::OneOrMany<serde_with::Same>,
8180											>::deserialize(deserializer)?))
8181										}
8182									}
8183									match map.next_value::<DeserializeWith>() {
8184										Ok(deserialize_with) => deserialize_with.0,
8185										Err(err) => {
8186											return Err(err);
8187										}
8188									}
8189								});
8190							}
8191							Field::TemporalCoverage => {
8192								if r#temporal_coverage_property.is_some() {
8193									return Err(<A::Error as de::Error>::duplicate_field(
8194										"temporalCoverage",
8195									));
8196								}
8197								r#temporal_coverage_property = Some({
8198									struct DeserializeWith(Vec<TemporalCoverageProperty>);
8199									impl<'de> Deserialize<'de> for DeserializeWith {
8200										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8201										where
8202											D: Deserializer<'de>,
8203										{
8204											Ok(DeserializeWith(serde_with::As::<
8205												serde_with::OneOrMany<serde_with::Same>,
8206											>::deserialize(deserializer)?))
8207										}
8208									}
8209									match map.next_value::<DeserializeWith>() {
8210										Ok(deserialize_with) => deserialize_with.0,
8211										Err(err) => {
8212											return Err(err);
8213										}
8214									}
8215								});
8216							}
8217							Field::Text => {
8218								if r#text_property.is_some() {
8219									return Err(<A::Error as de::Error>::duplicate_field("text"));
8220								}
8221								r#text_property = Some({
8222									struct DeserializeWith(Vec<TextProperty>);
8223									impl<'de> Deserialize<'de> for DeserializeWith {
8224										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8225										where
8226											D: Deserializer<'de>,
8227										{
8228											Ok(DeserializeWith(serde_with::As::<
8229												serde_with::OneOrMany<serde_with::Same>,
8230											>::deserialize(deserializer)?))
8231										}
8232									}
8233									match map.next_value::<DeserializeWith>() {
8234										Ok(deserialize_with) => deserialize_with.0,
8235										Err(err) => {
8236											return Err(err);
8237										}
8238									}
8239								});
8240							}
8241							Field::Thumbnail => {
8242								if r#thumbnail_property.is_some() {
8243									return Err(<A::Error as de::Error>::duplicate_field(
8244										"thumbnail",
8245									));
8246								}
8247								r#thumbnail_property = Some({
8248									struct DeserializeWith(Vec<ThumbnailProperty>);
8249									impl<'de> Deserialize<'de> for DeserializeWith {
8250										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8251										where
8252											D: Deserializer<'de>,
8253										{
8254											Ok(DeserializeWith(serde_with::As::<
8255												serde_with::OneOrMany<serde_with::Same>,
8256											>::deserialize(deserializer)?))
8257										}
8258									}
8259									match map.next_value::<DeserializeWith>() {
8260										Ok(deserialize_with) => deserialize_with.0,
8261										Err(err) => {
8262											return Err(err);
8263										}
8264									}
8265								});
8266							}
8267							Field::ThumbnailUrl => {
8268								if r#thumbnail_url_property.is_some() {
8269									return Err(<A::Error as de::Error>::duplicate_field(
8270										"thumbnailUrl",
8271									));
8272								}
8273								r#thumbnail_url_property = Some({
8274									struct DeserializeWith(Vec<ThumbnailUrlProperty>);
8275									impl<'de> Deserialize<'de> for DeserializeWith {
8276										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8277										where
8278											D: Deserializer<'de>,
8279										{
8280											Ok(DeserializeWith(serde_with::As::<
8281												serde_with::OneOrMany<serde_with::Same>,
8282											>::deserialize(deserializer)?))
8283										}
8284									}
8285									match map.next_value::<DeserializeWith>() {
8286										Ok(deserialize_with) => deserialize_with.0,
8287										Err(err) => {
8288											return Err(err);
8289										}
8290									}
8291								});
8292							}
8293							Field::TimeRequired => {
8294								if r#time_required_property.is_some() {
8295									return Err(<A::Error as de::Error>::duplicate_field(
8296										"timeRequired",
8297									));
8298								}
8299								r#time_required_property = Some({
8300									struct DeserializeWith(Vec<TimeRequiredProperty>);
8301									impl<'de> Deserialize<'de> for DeserializeWith {
8302										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8303										where
8304											D: Deserializer<'de>,
8305										{
8306											Ok(DeserializeWith(serde_with::As::<
8307												serde_with::OneOrMany<serde_with::Same>,
8308											>::deserialize(deserializer)?))
8309										}
8310									}
8311									match map.next_value::<DeserializeWith>() {
8312										Ok(deserialize_with) => deserialize_with.0,
8313										Err(err) => {
8314											return Err(err);
8315										}
8316									}
8317								});
8318							}
8319							Field::TranslationOfWork => {
8320								if r#translation_of_work_property.is_some() {
8321									return Err(<A::Error as de::Error>::duplicate_field(
8322										"translationOfWork",
8323									));
8324								}
8325								r#translation_of_work_property = Some({
8326									struct DeserializeWith(Vec<TranslationOfWorkProperty>);
8327									impl<'de> Deserialize<'de> for DeserializeWith {
8328										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8329										where
8330											D: Deserializer<'de>,
8331										{
8332											Ok(DeserializeWith(serde_with::As::<
8333												serde_with::OneOrMany<serde_with::Same>,
8334											>::deserialize(deserializer)?))
8335										}
8336									}
8337									match map.next_value::<DeserializeWith>() {
8338										Ok(deserialize_with) => deserialize_with.0,
8339										Err(err) => {
8340											return Err(err);
8341										}
8342									}
8343								});
8344							}
8345							Field::Translator => {
8346								if r#translator_property.is_some() {
8347									return Err(<A::Error as de::Error>::duplicate_field(
8348										"translator",
8349									));
8350								}
8351								r#translator_property = Some({
8352									struct DeserializeWith(Vec<TranslatorProperty>);
8353									impl<'de> Deserialize<'de> for DeserializeWith {
8354										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8355										where
8356											D: Deserializer<'de>,
8357										{
8358											Ok(DeserializeWith(serde_with::As::<
8359												serde_with::OneOrMany<serde_with::Same>,
8360											>::deserialize(deserializer)?))
8361										}
8362									}
8363									match map.next_value::<DeserializeWith>() {
8364										Ok(deserialize_with) => deserialize_with.0,
8365										Err(err) => {
8366											return Err(err);
8367										}
8368									}
8369								});
8370							}
8371							Field::TypicalAgeRange => {
8372								if r#typical_age_range_property.is_some() {
8373									return Err(<A::Error as de::Error>::duplicate_field(
8374										"typicalAgeRange",
8375									));
8376								}
8377								r#typical_age_range_property = Some({
8378									struct DeserializeWith(Vec<TypicalAgeRangeProperty>);
8379									impl<'de> Deserialize<'de> for DeserializeWith {
8380										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8381										where
8382											D: Deserializer<'de>,
8383										{
8384											Ok(DeserializeWith(serde_with::As::<
8385												serde_with::OneOrMany<serde_with::Same>,
8386											>::deserialize(deserializer)?))
8387										}
8388									}
8389									match map.next_value::<DeserializeWith>() {
8390										Ok(deserialize_with) => deserialize_with.0,
8391										Err(err) => {
8392											return Err(err);
8393										}
8394									}
8395								});
8396							}
8397							Field::UsageInfo => {
8398								if r#usage_info_property.is_some() {
8399									return Err(<A::Error as de::Error>::duplicate_field(
8400										"usageInfo",
8401									));
8402								}
8403								r#usage_info_property = Some({
8404									struct DeserializeWith(Vec<UsageInfoProperty>);
8405									impl<'de> Deserialize<'de> for DeserializeWith {
8406										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8407										where
8408											D: Deserializer<'de>,
8409										{
8410											Ok(DeserializeWith(serde_with::As::<
8411												serde_with::OneOrMany<serde_with::Same>,
8412											>::deserialize(deserializer)?))
8413										}
8414									}
8415									match map.next_value::<DeserializeWith>() {
8416										Ok(deserialize_with) => deserialize_with.0,
8417										Err(err) => {
8418											return Err(err);
8419										}
8420									}
8421								});
8422							}
8423							Field::Version => {
8424								if r#version_property.is_some() {
8425									return Err(<A::Error as de::Error>::duplicate_field(
8426										"version",
8427									));
8428								}
8429								r#version_property = Some({
8430									struct DeserializeWith(Vec<VersionProperty>);
8431									impl<'de> Deserialize<'de> for DeserializeWith {
8432										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8433										where
8434											D: Deserializer<'de>,
8435										{
8436											Ok(DeserializeWith(serde_with::As::<
8437												serde_with::OneOrMany<serde_with::Same>,
8438											>::deserialize(deserializer)?))
8439										}
8440									}
8441									match map.next_value::<DeserializeWith>() {
8442										Ok(deserialize_with) => deserialize_with.0,
8443										Err(err) => {
8444											return Err(err);
8445										}
8446									}
8447								});
8448							}
8449							Field::Video => {
8450								if r#video_property.is_some() {
8451									return Err(<A::Error as de::Error>::duplicate_field("video"));
8452								}
8453								r#video_property = Some({
8454									struct DeserializeWith(Vec<VideoProperty>);
8455									impl<'de> Deserialize<'de> for DeserializeWith {
8456										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8457										where
8458											D: Deserializer<'de>,
8459										{
8460											Ok(DeserializeWith(serde_with::As::<
8461												serde_with::OneOrMany<serde_with::Same>,
8462											>::deserialize(deserializer)?))
8463										}
8464									}
8465									match map.next_value::<DeserializeWith>() {
8466										Ok(deserialize_with) => deserialize_with.0,
8467										Err(err) => {
8468											return Err(err);
8469										}
8470									}
8471								});
8472							}
8473							Field::WorkExample => {
8474								if r#work_example_property.is_some() {
8475									return Err(<A::Error as de::Error>::duplicate_field(
8476										"workExample",
8477									));
8478								}
8479								r#work_example_property = Some({
8480									struct DeserializeWith(Vec<WorkExampleProperty>);
8481									impl<'de> Deserialize<'de> for DeserializeWith {
8482										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8483										where
8484											D: Deserializer<'de>,
8485										{
8486											Ok(DeserializeWith(serde_with::As::<
8487												serde_with::OneOrMany<serde_with::Same>,
8488											>::deserialize(deserializer)?))
8489										}
8490									}
8491									match map.next_value::<DeserializeWith>() {
8492										Ok(deserialize_with) => deserialize_with.0,
8493										Err(err) => {
8494											return Err(err);
8495										}
8496									}
8497								});
8498							}
8499							Field::WorkTranslation => {
8500								if r#work_translation_property.is_some() {
8501									return Err(<A::Error as de::Error>::duplicate_field(
8502										"workTranslation",
8503									));
8504								}
8505								r#work_translation_property = Some({
8506									struct DeserializeWith(Vec<WorkTranslationProperty>);
8507									impl<'de> Deserialize<'de> for DeserializeWith {
8508										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8509										where
8510											D: Deserializer<'de>,
8511										{
8512											Ok(DeserializeWith(serde_with::As::<
8513												serde_with::OneOrMany<serde_with::Same>,
8514											>::deserialize(deserializer)?))
8515										}
8516									}
8517									match map.next_value::<DeserializeWith>() {
8518										Ok(deserialize_with) => deserialize_with.0,
8519										Err(err) => {
8520											return Err(err);
8521										}
8522									}
8523								});
8524							}
8525							Field::CharacterAttribute => {
8526								if r#character_attribute_property.is_some() {
8527									return Err(<A::Error as de::Error>::duplicate_field(
8528										"characterAttribute",
8529									));
8530								}
8531								r#character_attribute_property = Some({
8532									struct DeserializeWith(Vec<CharacterAttributeProperty>);
8533									impl<'de> Deserialize<'de> for DeserializeWith {
8534										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8535										where
8536											D: Deserializer<'de>,
8537										{
8538											Ok(DeserializeWith(serde_with::As::<
8539												serde_with::OneOrMany<serde_with::Same>,
8540											>::deserialize(deserializer)?))
8541										}
8542									}
8543									match map.next_value::<DeserializeWith>() {
8544										Ok(deserialize_with) => deserialize_with.0,
8545										Err(err) => {
8546											return Err(err);
8547										}
8548									}
8549								});
8550							}
8551							Field::GameItem => {
8552								if r#game_item_property.is_some() {
8553									return Err(<A::Error as de::Error>::duplicate_field(
8554										"gameItem",
8555									));
8556								}
8557								r#game_item_property = Some({
8558									struct DeserializeWith(Vec<GameItemProperty>);
8559									impl<'de> Deserialize<'de> for DeserializeWith {
8560										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8561										where
8562											D: Deserializer<'de>,
8563										{
8564											Ok(DeserializeWith(serde_with::As::<
8565												serde_with::OneOrMany<serde_with::Same>,
8566											>::deserialize(deserializer)?))
8567										}
8568									}
8569									match map.next_value::<DeserializeWith>() {
8570										Ok(deserialize_with) => deserialize_with.0,
8571										Err(err) => {
8572											return Err(err);
8573										}
8574									}
8575								});
8576							}
8577							Field::GameLocation => {
8578								if r#game_location_property.is_some() {
8579									return Err(<A::Error as de::Error>::duplicate_field(
8580										"gameLocation",
8581									));
8582								}
8583								r#game_location_property = Some({
8584									struct DeserializeWith(Vec<GameLocationProperty>);
8585									impl<'de> Deserialize<'de> for DeserializeWith {
8586										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8587										where
8588											D: Deserializer<'de>,
8589										{
8590											Ok(DeserializeWith(serde_with::As::<
8591												serde_with::OneOrMany<serde_with::Same>,
8592											>::deserialize(deserializer)?))
8593										}
8594									}
8595									match map.next_value::<DeserializeWith>() {
8596										Ok(deserialize_with) => deserialize_with.0,
8597										Err(err) => {
8598											return Err(err);
8599										}
8600									}
8601								});
8602							}
8603							Field::NumberOfPlayers => {
8604								if r#number_of_players_property.is_some() {
8605									return Err(<A::Error as de::Error>::duplicate_field(
8606										"numberOfPlayers",
8607									));
8608								}
8609								r#number_of_players_property = Some({
8610									struct DeserializeWith(Vec<NumberOfPlayersProperty>);
8611									impl<'de> Deserialize<'de> for DeserializeWith {
8612										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8613										where
8614											D: Deserializer<'de>,
8615										{
8616											Ok(DeserializeWith(serde_with::As::<
8617												serde_with::OneOrMany<serde_with::Same>,
8618											>::deserialize(deserializer)?))
8619										}
8620									}
8621									match map.next_value::<DeserializeWith>() {
8622										Ok(deserialize_with) => deserialize_with.0,
8623										Err(err) => {
8624											return Err(err);
8625										}
8626									}
8627								});
8628							}
8629							Field::Quest => {
8630								if r#quest_property.is_some() {
8631									return Err(<A::Error as de::Error>::duplicate_field("quest"));
8632								}
8633								r#quest_property = Some({
8634									struct DeserializeWith(Vec<QuestProperty>);
8635									impl<'de> Deserialize<'de> for DeserializeWith {
8636										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8637										where
8638											D: Deserializer<'de>,
8639										{
8640											Ok(DeserializeWith(serde_with::As::<
8641												serde_with::OneOrMany<serde_with::Same>,
8642											>::deserialize(deserializer)?))
8643										}
8644									}
8645									match map.next_value::<DeserializeWith>() {
8646										Ok(deserialize_with) => deserialize_with.0,
8647										Err(err) => {
8648											return Err(err);
8649										}
8650									}
8651								});
8652							}
8653							Field::ApplicationCategory => {
8654								if r#application_category_property.is_some() {
8655									return Err(<A::Error as de::Error>::duplicate_field(
8656										"applicationCategory",
8657									));
8658								}
8659								r#application_category_property = Some({
8660									struct DeserializeWith(Vec<ApplicationCategoryProperty>);
8661									impl<'de> Deserialize<'de> for DeserializeWith {
8662										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8663										where
8664											D: Deserializer<'de>,
8665										{
8666											Ok(DeserializeWith(serde_with::As::<
8667												serde_with::OneOrMany<serde_with::Same>,
8668											>::deserialize(deserializer)?))
8669										}
8670									}
8671									match map.next_value::<DeserializeWith>() {
8672										Ok(deserialize_with) => deserialize_with.0,
8673										Err(err) => {
8674											return Err(err);
8675										}
8676									}
8677								});
8678							}
8679							Field::ApplicationSubCategory => {
8680								if r#application_sub_category_property.is_some() {
8681									return Err(<A::Error as de::Error>::duplicate_field(
8682										"applicationSubCategory",
8683									));
8684								}
8685								r#application_sub_category_property = Some({
8686									struct DeserializeWith(Vec<ApplicationSubCategoryProperty>);
8687									impl<'de> Deserialize<'de> for DeserializeWith {
8688										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8689										where
8690											D: Deserializer<'de>,
8691										{
8692											Ok(DeserializeWith(serde_with::As::<
8693												serde_with::OneOrMany<serde_with::Same>,
8694											>::deserialize(deserializer)?))
8695										}
8696									}
8697									match map.next_value::<DeserializeWith>() {
8698										Ok(deserialize_with) => deserialize_with.0,
8699										Err(err) => {
8700											return Err(err);
8701										}
8702									}
8703								});
8704							}
8705							Field::ApplicationSuite => {
8706								if r#application_suite_property.is_some() {
8707									return Err(<A::Error as de::Error>::duplicate_field(
8708										"applicationSuite",
8709									));
8710								}
8711								r#application_suite_property = Some({
8712									struct DeserializeWith(Vec<ApplicationSuiteProperty>);
8713									impl<'de> Deserialize<'de> for DeserializeWith {
8714										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8715										where
8716											D: Deserializer<'de>,
8717										{
8718											Ok(DeserializeWith(serde_with::As::<
8719												serde_with::OneOrMany<serde_with::Same>,
8720											>::deserialize(deserializer)?))
8721										}
8722									}
8723									match map.next_value::<DeserializeWith>() {
8724										Ok(deserialize_with) => deserialize_with.0,
8725										Err(err) => {
8726											return Err(err);
8727										}
8728									}
8729								});
8730							}
8731							Field::AvailableOnDevice => {
8732								if r#available_on_device_property.is_some() {
8733									return Err(<A::Error as de::Error>::duplicate_field(
8734										"availableOnDevice",
8735									));
8736								}
8737								r#available_on_device_property = Some({
8738									struct DeserializeWith(Vec<AvailableOnDeviceProperty>);
8739									impl<'de> Deserialize<'de> for DeserializeWith {
8740										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8741										where
8742											D: Deserializer<'de>,
8743										{
8744											Ok(DeserializeWith(serde_with::As::<
8745												serde_with::OneOrMany<serde_with::Same>,
8746											>::deserialize(deserializer)?))
8747										}
8748									}
8749									match map.next_value::<DeserializeWith>() {
8750										Ok(deserialize_with) => deserialize_with.0,
8751										Err(err) => {
8752											return Err(err);
8753										}
8754									}
8755								});
8756							}
8757							Field::CountriesNotSupported => {
8758								if r#countries_not_supported_property.is_some() {
8759									return Err(<A::Error as de::Error>::duplicate_field(
8760										"countriesNotSupported",
8761									));
8762								}
8763								r#countries_not_supported_property = Some({
8764									struct DeserializeWith(Vec<CountriesNotSupportedProperty>);
8765									impl<'de> Deserialize<'de> for DeserializeWith {
8766										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8767										where
8768											D: Deserializer<'de>,
8769										{
8770											Ok(DeserializeWith(serde_with::As::<
8771												serde_with::OneOrMany<serde_with::Same>,
8772											>::deserialize(deserializer)?))
8773										}
8774									}
8775									match map.next_value::<DeserializeWith>() {
8776										Ok(deserialize_with) => deserialize_with.0,
8777										Err(err) => {
8778											return Err(err);
8779										}
8780									}
8781								});
8782							}
8783							Field::CountriesSupported => {
8784								if r#countries_supported_property.is_some() {
8785									return Err(<A::Error as de::Error>::duplicate_field(
8786										"countriesSupported",
8787									));
8788								}
8789								r#countries_supported_property = Some({
8790									struct DeserializeWith(Vec<CountriesSupportedProperty>);
8791									impl<'de> Deserialize<'de> for DeserializeWith {
8792										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8793										where
8794											D: Deserializer<'de>,
8795										{
8796											Ok(DeserializeWith(serde_with::As::<
8797												serde_with::OneOrMany<serde_with::Same>,
8798											>::deserialize(deserializer)?))
8799										}
8800									}
8801									match map.next_value::<DeserializeWith>() {
8802										Ok(deserialize_with) => deserialize_with.0,
8803										Err(err) => {
8804											return Err(err);
8805										}
8806									}
8807								});
8808							}
8809							Field::Device => {
8810								if r#device_property.is_some() {
8811									return Err(<A::Error as de::Error>::duplicate_field("device"));
8812								}
8813								r#device_property = Some({
8814									struct DeserializeWith(Vec<DeviceProperty>);
8815									impl<'de> Deserialize<'de> for DeserializeWith {
8816										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8817										where
8818											D: Deserializer<'de>,
8819										{
8820											Ok(DeserializeWith(serde_with::As::<
8821												serde_with::OneOrMany<serde_with::Same>,
8822											>::deserialize(deserializer)?))
8823										}
8824									}
8825									match map.next_value::<DeserializeWith>() {
8826										Ok(deserialize_with) => deserialize_with.0,
8827										Err(err) => {
8828											return Err(err);
8829										}
8830									}
8831								});
8832							}
8833							Field::DownloadUrl => {
8834								if r#download_url_property.is_some() {
8835									return Err(<A::Error as de::Error>::duplicate_field(
8836										"downloadUrl",
8837									));
8838								}
8839								r#download_url_property = Some({
8840									struct DeserializeWith(Vec<DownloadUrlProperty>);
8841									impl<'de> Deserialize<'de> for DeserializeWith {
8842										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8843										where
8844											D: Deserializer<'de>,
8845										{
8846											Ok(DeserializeWith(serde_with::As::<
8847												serde_with::OneOrMany<serde_with::Same>,
8848											>::deserialize(deserializer)?))
8849										}
8850									}
8851									match map.next_value::<DeserializeWith>() {
8852										Ok(deserialize_with) => deserialize_with.0,
8853										Err(err) => {
8854											return Err(err);
8855										}
8856									}
8857								});
8858							}
8859							Field::FeatureList => {
8860								if r#feature_list_property.is_some() {
8861									return Err(<A::Error as de::Error>::duplicate_field(
8862										"featureList",
8863									));
8864								}
8865								r#feature_list_property = Some({
8866									struct DeserializeWith(Vec<FeatureListProperty>);
8867									impl<'de> Deserialize<'de> for DeserializeWith {
8868										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8869										where
8870											D: Deserializer<'de>,
8871										{
8872											Ok(DeserializeWith(serde_with::As::<
8873												serde_with::OneOrMany<serde_with::Same>,
8874											>::deserialize(deserializer)?))
8875										}
8876									}
8877									match map.next_value::<DeserializeWith>() {
8878										Ok(deserialize_with) => deserialize_with.0,
8879										Err(err) => {
8880											return Err(err);
8881										}
8882									}
8883								});
8884							}
8885							Field::FileSize => {
8886								if r#file_size_property.is_some() {
8887									return Err(<A::Error as de::Error>::duplicate_field(
8888										"fileSize",
8889									));
8890								}
8891								r#file_size_property = Some({
8892									struct DeserializeWith(Vec<FileSizeProperty>);
8893									impl<'de> Deserialize<'de> for DeserializeWith {
8894										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8895										where
8896											D: Deserializer<'de>,
8897										{
8898											Ok(DeserializeWith(serde_with::As::<
8899												serde_with::OneOrMany<serde_with::Same>,
8900											>::deserialize(deserializer)?))
8901										}
8902									}
8903									match map.next_value::<DeserializeWith>() {
8904										Ok(deserialize_with) => deserialize_with.0,
8905										Err(err) => {
8906											return Err(err);
8907										}
8908									}
8909								});
8910							}
8911							Field::InstallUrl => {
8912								if r#install_url_property.is_some() {
8913									return Err(<A::Error as de::Error>::duplicate_field(
8914										"installUrl",
8915									));
8916								}
8917								r#install_url_property = Some({
8918									struct DeserializeWith(Vec<InstallUrlProperty>);
8919									impl<'de> Deserialize<'de> for DeserializeWith {
8920										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8921										where
8922											D: Deserializer<'de>,
8923										{
8924											Ok(DeserializeWith(serde_with::As::<
8925												serde_with::OneOrMany<serde_with::Same>,
8926											>::deserialize(deserializer)?))
8927										}
8928									}
8929									match map.next_value::<DeserializeWith>() {
8930										Ok(deserialize_with) => deserialize_with.0,
8931										Err(err) => {
8932											return Err(err);
8933										}
8934									}
8935								});
8936							}
8937							Field::MemoryRequirements => {
8938								if r#memory_requirements_property.is_some() {
8939									return Err(<A::Error as de::Error>::duplicate_field(
8940										"memoryRequirements",
8941									));
8942								}
8943								r#memory_requirements_property = Some({
8944									struct DeserializeWith(Vec<MemoryRequirementsProperty>);
8945									impl<'de> Deserialize<'de> for DeserializeWith {
8946										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8947										where
8948											D: Deserializer<'de>,
8949										{
8950											Ok(DeserializeWith(serde_with::As::<
8951												serde_with::OneOrMany<serde_with::Same>,
8952											>::deserialize(deserializer)?))
8953										}
8954									}
8955									match map.next_value::<DeserializeWith>() {
8956										Ok(deserialize_with) => deserialize_with.0,
8957										Err(err) => {
8958											return Err(err);
8959										}
8960									}
8961								});
8962							}
8963							Field::OperatingSystem => {
8964								if r#operating_system_property.is_some() {
8965									return Err(<A::Error as de::Error>::duplicate_field(
8966										"operatingSystem",
8967									));
8968								}
8969								r#operating_system_property = Some({
8970									struct DeserializeWith(Vec<OperatingSystemProperty>);
8971									impl<'de> Deserialize<'de> for DeserializeWith {
8972										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8973										where
8974											D: Deserializer<'de>,
8975										{
8976											Ok(DeserializeWith(serde_with::As::<
8977												serde_with::OneOrMany<serde_with::Same>,
8978											>::deserialize(deserializer)?))
8979										}
8980									}
8981									match map.next_value::<DeserializeWith>() {
8982										Ok(deserialize_with) => deserialize_with.0,
8983										Err(err) => {
8984											return Err(err);
8985										}
8986									}
8987								});
8988							}
8989							Field::Permissions => {
8990								if r#permissions_property.is_some() {
8991									return Err(<A::Error as de::Error>::duplicate_field(
8992										"permissions",
8993									));
8994								}
8995								r#permissions_property = Some({
8996									struct DeserializeWith(Vec<PermissionsProperty>);
8997									impl<'de> Deserialize<'de> for DeserializeWith {
8998										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
8999										where
9000											D: Deserializer<'de>,
9001										{
9002											Ok(DeserializeWith(serde_with::As::<
9003												serde_with::OneOrMany<serde_with::Same>,
9004											>::deserialize(deserializer)?))
9005										}
9006									}
9007									match map.next_value::<DeserializeWith>() {
9008										Ok(deserialize_with) => deserialize_with.0,
9009										Err(err) => {
9010											return Err(err);
9011										}
9012									}
9013								});
9014							}
9015							Field::ProcessorRequirements => {
9016								if r#processor_requirements_property.is_some() {
9017									return Err(<A::Error as de::Error>::duplicate_field(
9018										"processorRequirements",
9019									));
9020								}
9021								r#processor_requirements_property = Some({
9022									struct DeserializeWith(Vec<ProcessorRequirementsProperty>);
9023									impl<'de> Deserialize<'de> for DeserializeWith {
9024										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9025										where
9026											D: Deserializer<'de>,
9027										{
9028											Ok(DeserializeWith(serde_with::As::<
9029												serde_with::OneOrMany<serde_with::Same>,
9030											>::deserialize(deserializer)?))
9031										}
9032									}
9033									match map.next_value::<DeserializeWith>() {
9034										Ok(deserialize_with) => deserialize_with.0,
9035										Err(err) => {
9036											return Err(err);
9037										}
9038									}
9039								});
9040							}
9041							Field::ReleaseNotes => {
9042								if r#release_notes_property.is_some() {
9043									return Err(<A::Error as de::Error>::duplicate_field(
9044										"releaseNotes",
9045									));
9046								}
9047								r#release_notes_property = Some({
9048									struct DeserializeWith(Vec<ReleaseNotesProperty>);
9049									impl<'de> Deserialize<'de> for DeserializeWith {
9050										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9051										where
9052											D: Deserializer<'de>,
9053										{
9054											Ok(DeserializeWith(serde_with::As::<
9055												serde_with::OneOrMany<serde_with::Same>,
9056											>::deserialize(deserializer)?))
9057										}
9058									}
9059									match map.next_value::<DeserializeWith>() {
9060										Ok(deserialize_with) => deserialize_with.0,
9061										Err(err) => {
9062											return Err(err);
9063										}
9064									}
9065								});
9066							}
9067							Field::Requirements => {
9068								if r#requirements_property.is_some() {
9069									return Err(<A::Error as de::Error>::duplicate_field(
9070										"requirements",
9071									));
9072								}
9073								r#requirements_property = Some({
9074									struct DeserializeWith(Vec<RequirementsProperty>);
9075									impl<'de> Deserialize<'de> for DeserializeWith {
9076										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9077										where
9078											D: Deserializer<'de>,
9079										{
9080											Ok(DeserializeWith(serde_with::As::<
9081												serde_with::OneOrMany<serde_with::Same>,
9082											>::deserialize(deserializer)?))
9083										}
9084									}
9085									match map.next_value::<DeserializeWith>() {
9086										Ok(deserialize_with) => deserialize_with.0,
9087										Err(err) => {
9088											return Err(err);
9089										}
9090									}
9091								});
9092							}
9093							Field::Screenshot => {
9094								if r#screenshot_property.is_some() {
9095									return Err(<A::Error as de::Error>::duplicate_field(
9096										"screenshot",
9097									));
9098								}
9099								r#screenshot_property = Some({
9100									struct DeserializeWith(Vec<ScreenshotProperty>);
9101									impl<'de> Deserialize<'de> for DeserializeWith {
9102										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9103										where
9104											D: Deserializer<'de>,
9105										{
9106											Ok(DeserializeWith(serde_with::As::<
9107												serde_with::OneOrMany<serde_with::Same>,
9108											>::deserialize(deserializer)?))
9109										}
9110									}
9111									match map.next_value::<DeserializeWith>() {
9112										Ok(deserialize_with) => deserialize_with.0,
9113										Err(err) => {
9114											return Err(err);
9115										}
9116									}
9117								});
9118							}
9119							Field::SoftwareAddOn => {
9120								if r#software_add_on_property.is_some() {
9121									return Err(<A::Error as de::Error>::duplicate_field(
9122										"softwareAddOn",
9123									));
9124								}
9125								r#software_add_on_property = Some({
9126									struct DeserializeWith(Vec<SoftwareAddOnProperty>);
9127									impl<'de> Deserialize<'de> for DeserializeWith {
9128										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9129										where
9130											D: Deserializer<'de>,
9131										{
9132											Ok(DeserializeWith(serde_with::As::<
9133												serde_with::OneOrMany<serde_with::Same>,
9134											>::deserialize(deserializer)?))
9135										}
9136									}
9137									match map.next_value::<DeserializeWith>() {
9138										Ok(deserialize_with) => deserialize_with.0,
9139										Err(err) => {
9140											return Err(err);
9141										}
9142									}
9143								});
9144							}
9145							Field::SoftwareHelp => {
9146								if r#software_help_property.is_some() {
9147									return Err(<A::Error as de::Error>::duplicate_field(
9148										"softwareHelp",
9149									));
9150								}
9151								r#software_help_property = Some({
9152									struct DeserializeWith(Vec<SoftwareHelpProperty>);
9153									impl<'de> Deserialize<'de> for DeserializeWith {
9154										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9155										where
9156											D: Deserializer<'de>,
9157										{
9158											Ok(DeserializeWith(serde_with::As::<
9159												serde_with::OneOrMany<serde_with::Same>,
9160											>::deserialize(deserializer)?))
9161										}
9162									}
9163									match map.next_value::<DeserializeWith>() {
9164										Ok(deserialize_with) => deserialize_with.0,
9165										Err(err) => {
9166											return Err(err);
9167										}
9168									}
9169								});
9170							}
9171							Field::SoftwareRequirements => {
9172								if r#software_requirements_property.is_some() {
9173									return Err(<A::Error as de::Error>::duplicate_field(
9174										"softwareRequirements",
9175									));
9176								}
9177								r#software_requirements_property = Some({
9178									struct DeserializeWith(Vec<SoftwareRequirementsProperty>);
9179									impl<'de> Deserialize<'de> for DeserializeWith {
9180										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9181										where
9182											D: Deserializer<'de>,
9183										{
9184											Ok(DeserializeWith(serde_with::As::<
9185												serde_with::OneOrMany<serde_with::Same>,
9186											>::deserialize(deserializer)?))
9187										}
9188									}
9189									match map.next_value::<DeserializeWith>() {
9190										Ok(deserialize_with) => deserialize_with.0,
9191										Err(err) => {
9192											return Err(err);
9193										}
9194									}
9195								});
9196							}
9197							Field::SoftwareVersion => {
9198								if r#software_version_property.is_some() {
9199									return Err(<A::Error as de::Error>::duplicate_field(
9200										"softwareVersion",
9201									));
9202								}
9203								r#software_version_property = Some({
9204									struct DeserializeWith(Vec<SoftwareVersionProperty>);
9205									impl<'de> Deserialize<'de> for DeserializeWith {
9206										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9207										where
9208											D: Deserializer<'de>,
9209										{
9210											Ok(DeserializeWith(serde_with::As::<
9211												serde_with::OneOrMany<serde_with::Same>,
9212											>::deserialize(deserializer)?))
9213										}
9214									}
9215									match map.next_value::<DeserializeWith>() {
9216										Ok(deserialize_with) => deserialize_with.0,
9217										Err(err) => {
9218											return Err(err);
9219										}
9220									}
9221								});
9222							}
9223							Field::StorageRequirements => {
9224								if r#storage_requirements_property.is_some() {
9225									return Err(<A::Error as de::Error>::duplicate_field(
9226										"storageRequirements",
9227									));
9228								}
9229								r#storage_requirements_property = Some({
9230									struct DeserializeWith(Vec<StorageRequirementsProperty>);
9231									impl<'de> Deserialize<'de> for DeserializeWith {
9232										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9233										where
9234											D: Deserializer<'de>,
9235										{
9236											Ok(DeserializeWith(serde_with::As::<
9237												serde_with::OneOrMany<serde_with::Same>,
9238											>::deserialize(deserializer)?))
9239										}
9240									}
9241									match map.next_value::<DeserializeWith>() {
9242										Ok(deserialize_with) => deserialize_with.0,
9243										Err(err) => {
9244											return Err(err);
9245										}
9246									}
9247								});
9248							}
9249							Field::SupportingData => {
9250								if r#supporting_data_property.is_some() {
9251									return Err(<A::Error as de::Error>::duplicate_field(
9252										"supportingData",
9253									));
9254								}
9255								r#supporting_data_property = Some({
9256									struct DeserializeWith(Vec<SupportingDataProperty>);
9257									impl<'de> Deserialize<'de> for DeserializeWith {
9258										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9259										where
9260											D: Deserializer<'de>,
9261										{
9262											Ok(DeserializeWith(serde_with::As::<
9263												serde_with::OneOrMany<serde_with::Same>,
9264											>::deserialize(deserializer)?))
9265										}
9266									}
9267									match map.next_value::<DeserializeWith>() {
9268										Ok(deserialize_with) => deserialize_with.0,
9269										Err(err) => {
9270											return Err(err);
9271										}
9272									}
9273								});
9274							}
9275							Field::AdditionalType => {
9276								if r#additional_type_property.is_some() {
9277									return Err(<A::Error as de::Error>::duplicate_field(
9278										"additionalType",
9279									));
9280								}
9281								r#additional_type_property = Some({
9282									struct DeserializeWith(Vec<AdditionalTypeProperty>);
9283									impl<'de> Deserialize<'de> for DeserializeWith {
9284										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9285										where
9286											D: Deserializer<'de>,
9287										{
9288											Ok(DeserializeWith(serde_with::As::<
9289												serde_with::OneOrMany<serde_with::Same>,
9290											>::deserialize(deserializer)?))
9291										}
9292									}
9293									match map.next_value::<DeserializeWith>() {
9294										Ok(deserialize_with) => deserialize_with.0,
9295										Err(err) => {
9296											return Err(err);
9297										}
9298									}
9299								});
9300							}
9301							Field::AlternateName => {
9302								if r#alternate_name_property.is_some() {
9303									return Err(<A::Error as de::Error>::duplicate_field(
9304										"alternateName",
9305									));
9306								}
9307								r#alternate_name_property = Some({
9308									struct DeserializeWith(Vec<AlternateNameProperty>);
9309									impl<'de> Deserialize<'de> for DeserializeWith {
9310										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9311										where
9312											D: Deserializer<'de>,
9313										{
9314											Ok(DeserializeWith(serde_with::As::<
9315												serde_with::OneOrMany<serde_with::Same>,
9316											>::deserialize(deserializer)?))
9317										}
9318									}
9319									match map.next_value::<DeserializeWith>() {
9320										Ok(deserialize_with) => deserialize_with.0,
9321										Err(err) => {
9322											return Err(err);
9323										}
9324									}
9325								});
9326							}
9327							Field::Description => {
9328								if r#description_property.is_some() {
9329									return Err(<A::Error as de::Error>::duplicate_field(
9330										"description",
9331									));
9332								}
9333								r#description_property = Some({
9334									struct DeserializeWith(Vec<DescriptionProperty>);
9335									impl<'de> Deserialize<'de> for DeserializeWith {
9336										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9337										where
9338											D: Deserializer<'de>,
9339										{
9340											Ok(DeserializeWith(serde_with::As::<
9341												serde_with::OneOrMany<serde_with::Same>,
9342											>::deserialize(deserializer)?))
9343										}
9344									}
9345									match map.next_value::<DeserializeWith>() {
9346										Ok(deserialize_with) => deserialize_with.0,
9347										Err(err) => {
9348											return Err(err);
9349										}
9350									}
9351								});
9352							}
9353							Field::DisambiguatingDescription => {
9354								if r#disambiguating_description_property.is_some() {
9355									return Err(<A::Error as de::Error>::duplicate_field(
9356										"disambiguatingDescription",
9357									));
9358								}
9359								r#disambiguating_description_property = Some({
9360									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
9361									impl<'de> Deserialize<'de> for DeserializeWith {
9362										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9363										where
9364											D: Deserializer<'de>,
9365										{
9366											Ok(DeserializeWith(serde_with::As::<
9367												serde_with::OneOrMany<serde_with::Same>,
9368											>::deserialize(deserializer)?))
9369										}
9370									}
9371									match map.next_value::<DeserializeWith>() {
9372										Ok(deserialize_with) => deserialize_with.0,
9373										Err(err) => {
9374											return Err(err);
9375										}
9376									}
9377								});
9378							}
9379							Field::Identifier => {
9380								if r#identifier_property.is_some() {
9381									return Err(<A::Error as de::Error>::duplicate_field(
9382										"identifier",
9383									));
9384								}
9385								r#identifier_property = Some({
9386									struct DeserializeWith(Vec<IdentifierProperty>);
9387									impl<'de> Deserialize<'de> for DeserializeWith {
9388										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9389										where
9390											D: Deserializer<'de>,
9391										{
9392											Ok(DeserializeWith(serde_with::As::<
9393												serde_with::OneOrMany<serde_with::Same>,
9394											>::deserialize(deserializer)?))
9395										}
9396									}
9397									match map.next_value::<DeserializeWith>() {
9398										Ok(deserialize_with) => deserialize_with.0,
9399										Err(err) => {
9400											return Err(err);
9401										}
9402									}
9403								});
9404							}
9405							Field::Image => {
9406								if r#image_property.is_some() {
9407									return Err(<A::Error as de::Error>::duplicate_field("image"));
9408								}
9409								r#image_property = Some({
9410									struct DeserializeWith(Vec<ImageProperty>);
9411									impl<'de> Deserialize<'de> for DeserializeWith {
9412										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9413										where
9414											D: Deserializer<'de>,
9415										{
9416											Ok(DeserializeWith(serde_with::As::<
9417												serde_with::OneOrMany<serde_with::Same>,
9418											>::deserialize(deserializer)?))
9419										}
9420									}
9421									match map.next_value::<DeserializeWith>() {
9422										Ok(deserialize_with) => deserialize_with.0,
9423										Err(err) => {
9424											return Err(err);
9425										}
9426									}
9427								});
9428							}
9429							Field::MainEntityOfPage => {
9430								if r#main_entity_of_page_property.is_some() {
9431									return Err(<A::Error as de::Error>::duplicate_field(
9432										"mainEntityOfPage",
9433									));
9434								}
9435								r#main_entity_of_page_property = Some({
9436									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
9437									impl<'de> Deserialize<'de> for DeserializeWith {
9438										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9439										where
9440											D: Deserializer<'de>,
9441										{
9442											Ok(DeserializeWith(serde_with::As::<
9443												serde_with::OneOrMany<serde_with::Same>,
9444											>::deserialize(deserializer)?))
9445										}
9446									}
9447									match map.next_value::<DeserializeWith>() {
9448										Ok(deserialize_with) => deserialize_with.0,
9449										Err(err) => {
9450											return Err(err);
9451										}
9452									}
9453								});
9454							}
9455							Field::Name => {
9456								if r#name_property.is_some() {
9457									return Err(<A::Error as de::Error>::duplicate_field("name"));
9458								}
9459								r#name_property = Some({
9460									struct DeserializeWith(Vec<NameProperty>);
9461									impl<'de> Deserialize<'de> for DeserializeWith {
9462										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9463										where
9464											D: Deserializer<'de>,
9465										{
9466											Ok(DeserializeWith(serde_with::As::<
9467												serde_with::OneOrMany<serde_with::Same>,
9468											>::deserialize(deserializer)?))
9469										}
9470									}
9471									match map.next_value::<DeserializeWith>() {
9472										Ok(deserialize_with) => deserialize_with.0,
9473										Err(err) => {
9474											return Err(err);
9475										}
9476									}
9477								});
9478							}
9479							Field::PotentialAction => {
9480								if r#potential_action_property.is_some() {
9481									return Err(<A::Error as de::Error>::duplicate_field(
9482										"potentialAction",
9483									));
9484								}
9485								r#potential_action_property = Some({
9486									struct DeserializeWith(Vec<PotentialActionProperty>);
9487									impl<'de> Deserialize<'de> for DeserializeWith {
9488										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9489										where
9490											D: Deserializer<'de>,
9491										{
9492											Ok(DeserializeWith(serde_with::As::<
9493												serde_with::OneOrMany<serde_with::Same>,
9494											>::deserialize(deserializer)?))
9495										}
9496									}
9497									match map.next_value::<DeserializeWith>() {
9498										Ok(deserialize_with) => deserialize_with.0,
9499										Err(err) => {
9500											return Err(err);
9501										}
9502									}
9503								});
9504							}
9505							Field::SameAs => {
9506								if r#same_as_property.is_some() {
9507									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
9508								}
9509								r#same_as_property = Some({
9510									struct DeserializeWith(Vec<SameAsProperty>);
9511									impl<'de> Deserialize<'de> for DeserializeWith {
9512										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9513										where
9514											D: Deserializer<'de>,
9515										{
9516											Ok(DeserializeWith(serde_with::As::<
9517												serde_with::OneOrMany<serde_with::Same>,
9518											>::deserialize(deserializer)?))
9519										}
9520									}
9521									match map.next_value::<DeserializeWith>() {
9522										Ok(deserialize_with) => deserialize_with.0,
9523										Err(err) => {
9524											return Err(err);
9525										}
9526									}
9527								});
9528							}
9529							Field::SubjectOf => {
9530								if r#subject_of_property.is_some() {
9531									return Err(<A::Error as de::Error>::duplicate_field(
9532										"subjectOf",
9533									));
9534								}
9535								r#subject_of_property = Some({
9536									struct DeserializeWith(Vec<SubjectOfProperty>);
9537									impl<'de> Deserialize<'de> for DeserializeWith {
9538										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9539										where
9540											D: Deserializer<'de>,
9541										{
9542											Ok(DeserializeWith(serde_with::As::<
9543												serde_with::OneOrMany<serde_with::Same>,
9544											>::deserialize(deserializer)?))
9545										}
9546									}
9547									match map.next_value::<DeserializeWith>() {
9548										Ok(deserialize_with) => deserialize_with.0,
9549										Err(err) => {
9550											return Err(err);
9551										}
9552									}
9553								});
9554							}
9555							Field::Url => {
9556								if r#url_property.is_some() {
9557									return Err(<A::Error as de::Error>::duplicate_field("url"));
9558								}
9559								r#url_property = Some({
9560									struct DeserializeWith(Vec<UrlProperty>);
9561									impl<'de> Deserialize<'de> for DeserializeWith {
9562										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
9563										where
9564											D: Deserializer<'de>,
9565										{
9566											Ok(DeserializeWith(serde_with::As::<
9567												serde_with::OneOrMany<serde_with::Same>,
9568											>::deserialize(deserializer)?))
9569										}
9570									}
9571									match map.next_value::<DeserializeWith>() {
9572										Ok(deserialize_with) => deserialize_with.0,
9573										Err(err) => {
9574											return Err(err);
9575										}
9576									}
9577								});
9578							}
9579							Field::Ignore => {
9580								let _ = map.next_value::<de::IgnoredAny>()?;
9581							}
9582						}
9583					}
9584					Ok(VideoGame {
9585						r#actor: r#actor_property.unwrap_or_default(),
9586						r#actors: r#actors_property.unwrap_or_default(),
9587						r#cheat_code: r#cheat_code_property.unwrap_or_default(),
9588						r#director: r#director_property.unwrap_or_default(),
9589						r#directors: r#directors_property.unwrap_or_default(),
9590						r#game_edition: r#game_edition_property.unwrap_or_default(),
9591						r#game_platform: r#game_platform_property.unwrap_or_default(),
9592						r#game_server: r#game_server_property.unwrap_or_default(),
9593						r#game_tip: r#game_tip_property.unwrap_or_default(),
9594						r#music_by: r#music_by_property.unwrap_or_default(),
9595						r#play_mode: r#play_mode_property.unwrap_or_default(),
9596						r#trailer: r#trailer_property.unwrap_or_default(),
9597						r#about: r#about_property.unwrap_or_default(),
9598						r#abstract: r#abstract_property.unwrap_or_default(),
9599						r#access_mode: r#access_mode_property.unwrap_or_default(),
9600						r#access_mode_sufficient: r#access_mode_sufficient_property
9601							.unwrap_or_default(),
9602						r#accessibility_api: r#accessibility_api_property.unwrap_or_default(),
9603						r#accessibility_control: r#accessibility_control_property
9604							.unwrap_or_default(),
9605						r#accessibility_feature: r#accessibility_feature_property
9606							.unwrap_or_default(),
9607						r#accessibility_hazard: r#accessibility_hazard_property.unwrap_or_default(),
9608						r#accessibility_summary: r#accessibility_summary_property
9609							.unwrap_or_default(),
9610						r#accountable_person: r#accountable_person_property.unwrap_or_default(),
9611						r#acquire_license_page: r#acquire_license_page_property.unwrap_or_default(),
9612						r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
9613						r#alternative_headline: r#alternative_headline_property.unwrap_or_default(),
9614						r#archived_at: r#archived_at_property.unwrap_or_default(),
9615						r#assesses: r#assesses_property.unwrap_or_default(),
9616						r#associated_media: r#associated_media_property.unwrap_or_default(),
9617						r#audience: r#audience_property.unwrap_or_default(),
9618						r#audio: r#audio_property.unwrap_or_default(),
9619						r#author: r#author_property.unwrap_or_default(),
9620						r#award: r#award_property.unwrap_or_default(),
9621						r#awards: r#awards_property.unwrap_or_default(),
9622						r#character: r#character_property.unwrap_or_default(),
9623						r#citation: r#citation_property.unwrap_or_default(),
9624						r#comment: r#comment_property.unwrap_or_default(),
9625						r#comment_count: r#comment_count_property.unwrap_or_default(),
9626						r#conditions_of_access: r#conditions_of_access_property.unwrap_or_default(),
9627						r#content_location: r#content_location_property.unwrap_or_default(),
9628						r#content_rating: r#content_rating_property.unwrap_or_default(),
9629						r#content_reference_time: r#content_reference_time_property
9630							.unwrap_or_default(),
9631						r#contributor: r#contributor_property.unwrap_or_default(),
9632						r#copyright_holder: r#copyright_holder_property.unwrap_or_default(),
9633						r#copyright_notice: r#copyright_notice_property.unwrap_or_default(),
9634						r#copyright_year: r#copyright_year_property.unwrap_or_default(),
9635						r#correction: r#correction_property.unwrap_or_default(),
9636						r#country_of_origin: r#country_of_origin_property.unwrap_or_default(),
9637						r#creative_work_status: r#creative_work_status_property.unwrap_or_default(),
9638						r#creator: r#creator_property.unwrap_or_default(),
9639						r#credit_text: r#credit_text_property.unwrap_or_default(),
9640						r#date_created: r#date_created_property.unwrap_or_default(),
9641						r#date_modified: r#date_modified_property.unwrap_or_default(),
9642						r#date_published: r#date_published_property.unwrap_or_default(),
9643						r#discussion_url: r#discussion_url_property.unwrap_or_default(),
9644						r#edit_eidr: r#edit_eidr_property.unwrap_or_default(),
9645						r#editor: r#editor_property.unwrap_or_default(),
9646						r#educational_alignment: r#educational_alignment_property
9647							.unwrap_or_default(),
9648						r#educational_level: r#educational_level_property.unwrap_or_default(),
9649						r#educational_use: r#educational_use_property.unwrap_or_default(),
9650						r#encoding: r#encoding_property.unwrap_or_default(),
9651						r#encoding_format: r#encoding_format_property.unwrap_or_default(),
9652						r#encodings: r#encodings_property.unwrap_or_default(),
9653						r#example_of_work: r#example_of_work_property.unwrap_or_default(),
9654						r#expires: r#expires_property.unwrap_or_default(),
9655						r#file_format: r#file_format_property.unwrap_or_default(),
9656						r#funder: r#funder_property.unwrap_or_default(),
9657						r#funding: r#funding_property.unwrap_or_default(),
9658						r#genre: r#genre_property.unwrap_or_default(),
9659						r#has_part: r#has_part_property.unwrap_or_default(),
9660						r#headline: r#headline_property.unwrap_or_default(),
9661						r#in_language: r#in_language_property.unwrap_or_default(),
9662						r#interaction_statistic: r#interaction_statistic_property
9663							.unwrap_or_default(),
9664						r#interactivity_type: r#interactivity_type_property.unwrap_or_default(),
9665						r#interpreted_as_claim: r#interpreted_as_claim_property.unwrap_or_default(),
9666						r#is_accessible_for_free: r#is_accessible_for_free_property
9667							.unwrap_or_default(),
9668						r#is_based_on: r#is_based_on_property.unwrap_or_default(),
9669						r#is_based_on_url: r#is_based_on_url_property.unwrap_or_default(),
9670						r#is_family_friendly: r#is_family_friendly_property.unwrap_or_default(),
9671						r#is_part_of: r#is_part_of_property.unwrap_or_default(),
9672						r#keywords: r#keywords_property.unwrap_or_default(),
9673						r#learning_resource_type: r#learning_resource_type_property
9674							.unwrap_or_default(),
9675						r#license: r#license_property.unwrap_or_default(),
9676						r#location_created: r#location_created_property.unwrap_or_default(),
9677						r#main_entity: r#main_entity_property.unwrap_or_default(),
9678						r#maintainer: r#maintainer_property.unwrap_or_default(),
9679						r#material: r#material_property.unwrap_or_default(),
9680						r#material_extent: r#material_extent_property.unwrap_or_default(),
9681						r#mentions: r#mentions_property.unwrap_or_default(),
9682						r#offers: r#offers_property.unwrap_or_default(),
9683						r#pattern: r#pattern_property.unwrap_or_default(),
9684						r#position: r#position_property.unwrap_or_default(),
9685						r#producer: r#producer_property.unwrap_or_default(),
9686						r#provider: r#provider_property.unwrap_or_default(),
9687						r#publication: r#publication_property.unwrap_or_default(),
9688						r#publisher: r#publisher_property.unwrap_or_default(),
9689						r#publisher_imprint: r#publisher_imprint_property.unwrap_or_default(),
9690						r#publishing_principles: r#publishing_principles_property
9691							.unwrap_or_default(),
9692						r#recorded_at: r#recorded_at_property.unwrap_or_default(),
9693						r#released_event: r#released_event_property.unwrap_or_default(),
9694						r#review: r#review_property.unwrap_or_default(),
9695						r#reviews: r#reviews_property.unwrap_or_default(),
9696						r#schema_version: r#schema_version_property.unwrap_or_default(),
9697						r#sd_date_published: r#sd_date_published_property.unwrap_or_default(),
9698						r#sd_license: r#sd_license_property.unwrap_or_default(),
9699						r#sd_publisher: r#sd_publisher_property.unwrap_or_default(),
9700						r#size: r#size_property.unwrap_or_default(),
9701						r#source_organization: r#source_organization_property.unwrap_or_default(),
9702						r#spatial: r#spatial_property.unwrap_or_default(),
9703						r#spatial_coverage: r#spatial_coverage_property.unwrap_or_default(),
9704						r#sponsor: r#sponsor_property.unwrap_or_default(),
9705						r#teaches: r#teaches_property.unwrap_or_default(),
9706						r#temporal: r#temporal_property.unwrap_or_default(),
9707						r#temporal_coverage: r#temporal_coverage_property.unwrap_or_default(),
9708						r#text: r#text_property.unwrap_or_default(),
9709						r#thumbnail: r#thumbnail_property.unwrap_or_default(),
9710						r#thumbnail_url: r#thumbnail_url_property.unwrap_or_default(),
9711						r#time_required: r#time_required_property.unwrap_or_default(),
9712						r#translation_of_work: r#translation_of_work_property.unwrap_or_default(),
9713						r#translator: r#translator_property.unwrap_or_default(),
9714						r#typical_age_range: r#typical_age_range_property.unwrap_or_default(),
9715						r#usage_info: r#usage_info_property.unwrap_or_default(),
9716						r#version: r#version_property.unwrap_or_default(),
9717						r#video: r#video_property.unwrap_or_default(),
9718						r#work_example: r#work_example_property.unwrap_or_default(),
9719						r#work_translation: r#work_translation_property.unwrap_or_default(),
9720						r#character_attribute: r#character_attribute_property.unwrap_or_default(),
9721						r#game_item: r#game_item_property.unwrap_or_default(),
9722						r#game_location: r#game_location_property.unwrap_or_default(),
9723						r#number_of_players: r#number_of_players_property.unwrap_or_default(),
9724						r#quest: r#quest_property.unwrap_or_default(),
9725						r#application_category: r#application_category_property.unwrap_or_default(),
9726						r#application_sub_category: r#application_sub_category_property
9727							.unwrap_or_default(),
9728						r#application_suite: r#application_suite_property.unwrap_or_default(),
9729						r#available_on_device: r#available_on_device_property.unwrap_or_default(),
9730						r#countries_not_supported: r#countries_not_supported_property
9731							.unwrap_or_default(),
9732						r#countries_supported: r#countries_supported_property.unwrap_or_default(),
9733						r#device: r#device_property.unwrap_or_default(),
9734						r#download_url: r#download_url_property.unwrap_or_default(),
9735						r#feature_list: r#feature_list_property.unwrap_or_default(),
9736						r#file_size: r#file_size_property.unwrap_or_default(),
9737						r#install_url: r#install_url_property.unwrap_or_default(),
9738						r#memory_requirements: r#memory_requirements_property.unwrap_or_default(),
9739						r#operating_system: r#operating_system_property.unwrap_or_default(),
9740						r#permissions: r#permissions_property.unwrap_or_default(),
9741						r#processor_requirements: r#processor_requirements_property
9742							.unwrap_or_default(),
9743						r#release_notes: r#release_notes_property.unwrap_or_default(),
9744						r#requirements: r#requirements_property.unwrap_or_default(),
9745						r#screenshot: r#screenshot_property.unwrap_or_default(),
9746						r#software_add_on: r#software_add_on_property.unwrap_or_default(),
9747						r#software_help: r#software_help_property.unwrap_or_default(),
9748						r#software_requirements: r#software_requirements_property
9749							.unwrap_or_default(),
9750						r#software_version: r#software_version_property.unwrap_or_default(),
9751						r#storage_requirements: r#storage_requirements_property.unwrap_or_default(),
9752						r#supporting_data: r#supporting_data_property.unwrap_or_default(),
9753						r#additional_type: r#additional_type_property.unwrap_or_default(),
9754						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
9755						r#description: r#description_property.unwrap_or_default(),
9756						r#disambiguating_description: r#disambiguating_description_property
9757							.unwrap_or_default(),
9758						r#identifier: r#identifier_property.unwrap_or_default(),
9759						r#image: r#image_property.unwrap_or_default(),
9760						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
9761						r#name: r#name_property.unwrap_or_default(),
9762						r#potential_action: r#potential_action_property.unwrap_or_default(),
9763						r#same_as: r#same_as_property.unwrap_or_default(),
9764						r#subject_of: r#subject_of_property.unwrap_or_default(),
9765						r#url: r#url_property.unwrap_or_default(),
9766					})
9767				}
9768			}
9769			const FIELDS: &[&str] = &[
9770				"actor",
9771				"actors",
9772				"cheatCode",
9773				"director",
9774				"directors",
9775				"gameEdition",
9776				"gamePlatform",
9777				"gameServer",
9778				"gameTip",
9779				"musicBy",
9780				"playMode",
9781				"trailer",
9782				"about",
9783				"abstract",
9784				"accessMode",
9785				"accessModeSufficient",
9786				"accessibilityAPI",
9787				"accessibilityControl",
9788				"accessibilityFeature",
9789				"accessibilityHazard",
9790				"accessibilitySummary",
9791				"accountablePerson",
9792				"acquireLicensePage",
9793				"aggregateRating",
9794				"alternativeHeadline",
9795				"archivedAt",
9796				"assesses",
9797				"associatedMedia",
9798				"audience",
9799				"audio",
9800				"author",
9801				"award",
9802				"awards",
9803				"character",
9804				"citation",
9805				"comment",
9806				"commentCount",
9807				"conditionsOfAccess",
9808				"contentLocation",
9809				"contentRating",
9810				"contentReferenceTime",
9811				"contributor",
9812				"copyrightHolder",
9813				"copyrightNotice",
9814				"copyrightYear",
9815				"correction",
9816				"countryOfOrigin",
9817				"creativeWorkStatus",
9818				"creator",
9819				"creditText",
9820				"dateCreated",
9821				"dateModified",
9822				"datePublished",
9823				"discussionUrl",
9824				"editEIDR",
9825				"editor",
9826				"educationalAlignment",
9827				"educationalLevel",
9828				"educationalUse",
9829				"encoding",
9830				"encodingFormat",
9831				"encodings",
9832				"exampleOfWork",
9833				"expires",
9834				"fileFormat",
9835				"funder",
9836				"funding",
9837				"genre",
9838				"hasPart",
9839				"headline",
9840				"inLanguage",
9841				"interactionStatistic",
9842				"interactivityType",
9843				"interpretedAsClaim",
9844				"isAccessibleForFree",
9845				"isBasedOn",
9846				"isBasedOnUrl",
9847				"isFamilyFriendly",
9848				"isPartOf",
9849				"keywords",
9850				"learningResourceType",
9851				"license",
9852				"locationCreated",
9853				"mainEntity",
9854				"maintainer",
9855				"material",
9856				"materialExtent",
9857				"mentions",
9858				"offers",
9859				"pattern",
9860				"position",
9861				"producer",
9862				"provider",
9863				"publication",
9864				"publisher",
9865				"publisherImprint",
9866				"publishingPrinciples",
9867				"recordedAt",
9868				"releasedEvent",
9869				"review",
9870				"reviews",
9871				"schemaVersion",
9872				"sdDatePublished",
9873				"sdLicense",
9874				"sdPublisher",
9875				"size",
9876				"sourceOrganization",
9877				"spatial",
9878				"spatialCoverage",
9879				"sponsor",
9880				"teaches",
9881				"temporal",
9882				"temporalCoverage",
9883				"text",
9884				"thumbnail",
9885				"thumbnailUrl",
9886				"timeRequired",
9887				"translationOfWork",
9888				"translator",
9889				"typicalAgeRange",
9890				"usageInfo",
9891				"version",
9892				"video",
9893				"workExample",
9894				"workTranslation",
9895				"characterAttribute",
9896				"gameItem",
9897				"gameLocation",
9898				"numberOfPlayers",
9899				"quest",
9900				"applicationCategory",
9901				"applicationSubCategory",
9902				"applicationSuite",
9903				"availableOnDevice",
9904				"countriesNotSupported",
9905				"countriesSupported",
9906				"device",
9907				"downloadUrl",
9908				"featureList",
9909				"fileSize",
9910				"installUrl",
9911				"memoryRequirements",
9912				"operatingSystem",
9913				"permissions",
9914				"processorRequirements",
9915				"releaseNotes",
9916				"requirements",
9917				"screenshot",
9918				"softwareAddOn",
9919				"softwareHelp",
9920				"softwareRequirements",
9921				"softwareVersion",
9922				"storageRequirements",
9923				"supportingData",
9924				"additionalType",
9925				"alternateName",
9926				"description",
9927				"disambiguatingDescription",
9928				"identifier",
9929				"image",
9930				"mainEntityOfPage",
9931				"name",
9932				"potentialAction",
9933				"sameAs",
9934				"subjectOf",
9935				"url",
9936			];
9937			deserializer.deserialize_struct("VideoGame", FIELDS, ClassVisitor)
9938		}
9939	}
9940}
schema_org_types/schemas/classes/video_game.rs

schema_org_types/schemas/classes/
video_game.rs
