schema_org_types/schemas/classes/
mobile_application.rs

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

schema_org_types/schemas/classes/
mobile_application.rs
