schema_org_types/schemas/classes/
recipe.rs

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

schema_org_types/schemas/classes/
recipe.rs
