// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: social.flockfeeds.lexical.type.Recipe
//
// This file was automatically generated from Lexicon schemas.
// Any manual changes will be overwritten on the next regeneration.

#[allow(unused_imports)]
use alloc::collections::BTreeMap;

#[allow(unused_imports)]
use core::marker::PhantomData;
use jacquard_common::{CowStr, BosStr, DefaultStr, FromStaticStr};

#[allow(unused_imports)]
use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
use jacquard_common::deps::smol_str::SmolStr;
use jacquard_common::types::collection::{Collection, RecordError};
use jacquard_common::types::string::{AtUri, Cid};
use jacquard_common::types::uri::{RecordUri, UriError};
use jacquard_common::types::value::Data;
use jacquard_common::xrpc::XrpcResp;
use jacquard_derive::{IntoStatic, lexicon, open_union};
use jacquard_lexicon::lexicon::LexiconDoc;
use jacquard_lexicon::schema::LexiconSchema;

#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Serialize, Deserialize};
use crate::social_flockfeeds::lexical::r#type::event;
use crate::social_flockfeeds::lexical::r#type::image_object;
use crate::social_flockfeeds::lexical::r#type::offer;
use crate::social_flockfeeds::lexical::r#type::organization;
use crate::social_flockfeeds::lexical::r#type::person;
use crate::social_flockfeeds::lexical::r#type::product;
/// A recipe. For dietary restrictions covered by the recipe, a few common restrictions are enumerated via [[suitableForDiet]]. The [[keywords]] property can also be used to add more detail.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct Embedded<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub about: Option<EmbeddedAbout<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#abstract: Option<EmbeddedAbstract<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub access_mode: Option<EmbeddedAccessMode<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub access_mode_sufficient: Option<EmbeddedAccessModeSufficient<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_api: Option<EmbeddedAccessibilityApi<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_control: Option<EmbeddedAccessibilityControl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_feature: Option<EmbeddedAccessibilityFeature<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_hazard: Option<EmbeddedAccessibilityHazard<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_summary: Option<EmbeddedAccessibilitySummary<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accountable_person: Option<EmbeddedAccountablePerson<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub acquire_license_page: Option<EmbeddedAcquireLicensePage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_type: Option<EmbeddedAdditionalType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aggregate_rating: Option<EmbeddedAggregateRating<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternate_name: Option<EmbeddedAlternateName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternative_headline: Option<EmbeddedAlternativeHeadline<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub archived_at: Option<EmbeddedArchivedAt<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub assesses: Option<EmbeddedAssesses<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub associated_media: Option<EmbeddedAssociatedMedia<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audience: Option<EmbeddedAudience<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audio: Option<EmbeddedAudio<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub author: Option<EmbeddedAuthor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub award: Option<EmbeddedAward<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awards: Option<EmbeddedAwards<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub character: Option<EmbeddedCharacter<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub citation: Option<EmbeddedCitation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<EmbeddedComment<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment_count: Option<EmbeddedCommentCount<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conditions_of_access: Option<EmbeddedConditionsOfAccess<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_location: Option<EmbeddedContentLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_rating: Option<EmbeddedContentRating<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_reference_time: Option<EmbeddedContentReferenceTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contributor: Option<EmbeddedContributor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cook_time: Option<EmbeddedCookTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cooking_method: Option<EmbeddedCookingMethod<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_holder: Option<EmbeddedCopyrightHolder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_notice: Option<EmbeddedCopyrightNotice<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_year: Option<EmbeddedCopyrightYear<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correction: Option<EmbeddedCorrection<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_of_origin: Option<EmbeddedCountryOfOrigin<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creative_work_status: Option<EmbeddedCreativeWorkStatus<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creator: Option<EmbeddedCreator<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub credit_text: Option<EmbeddedCreditText<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_created: Option<EmbeddedDateCreated<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_modified: Option<EmbeddedDateModified<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_published: Option<EmbeddedDatePublished<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<EmbeddedDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digital_source_type: Option<EmbeddedDigitalSourceType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disambiguating_description: Option<EmbeddedDisambiguatingDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub discussion_url: Option<EmbeddedDiscussionUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_eidr: Option<EmbeddedEditEidr<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor: Option<EmbeddedEditor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_alignment: Option<EmbeddedEducationalAlignment<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_level: Option<EmbeddedEducationalLevel<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_use: Option<EmbeddedEducationalUse<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding: Option<EmbeddedEncoding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding_format: Option<EmbeddedEncodingFormat<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encodings: Option<EmbeddedEncodings<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub estimated_cost: Option<EmbeddedEstimatedCost<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub example_of_work: Option<EmbeddedExampleOfWork<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires: Option<EmbeddedExpires<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_format: Option<EmbeddedFileFormat<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funder: Option<EmbeddedFunder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funding: Option<EmbeddedFunding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub genre: Option<EmbeddedGenre<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_part: Option<EmbeddedHasPart<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub headline: Option<EmbeddedHeadline<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifier: Option<EmbeddedIdentifier<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<EmbeddedImage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub in_language: Option<EmbeddedInLanguage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ingredients: Option<EmbeddedIngredients<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interaction_statistic: Option<EmbeddedInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interactivity_type: Option<EmbeddedInteractivityType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpreted_as_claim: Option<EmbeddedInterpretedAsClaim<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_accessible_for_free: Option<EmbeddedIsAccessibleForFree<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_based_on: Option<EmbeddedIsBasedOn<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_based_on_url: Option<EmbeddedIsBasedOnUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_family_friendly: Option<EmbeddedIsFamilyFriendly<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_part_of: Option<EmbeddedIsPartOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub keywords: Option<EmbeddedKeywords<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub learning_resource_type: Option<EmbeddedLearningResourceType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub license: Option<EmbeddedLicense<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_created: Option<EmbeddedLocationCreated<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity: Option<EmbeddedMainEntity<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity_of_page: Option<EmbeddedMainEntityOfPage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maintainer: Option<EmbeddedMaintainer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub material: Option<EmbeddedMaterial<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub material_extent: Option<EmbeddedMaterialExtent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mentions: Option<EmbeddedMentions<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<EmbeddedName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nutrition: Option<EmbeddedNutrition<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offers: Option<EmbeddedOffers<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<EmbeddedPattern<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub perform_time: Option<EmbeddedPerformTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub position: Option<EmbeddedPosition<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub potential_action: Option<EmbeddedPotentialAction<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prep_time: Option<EmbeddedPrepTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub producer: Option<EmbeddedProducer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<EmbeddedProvider<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publication: Option<EmbeddedPublication<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher: Option<EmbeddedPublisher<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher_imprint: Option<EmbeddedPublisherImprint<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publishing_principles: Option<EmbeddedPublishingPrinciples<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_category: Option<EmbeddedRecipeCategory<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_cuisine: Option<EmbeddedRecipeCuisine<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_ingredient: Option<EmbeddedRecipeIngredient<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_instructions: Option<EmbeddedRecipeInstructions<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_yield: Option<EmbeddedRecipeYield<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recorded_at: Option<EmbeddedRecordedAt<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub released_event: Option<EmbeddedReleasedEvent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub review: Option<EmbeddedReview<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reviews: Option<EmbeddedReviews<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub same_as: Option<EmbeddedSameAs<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub schema_version: Option<EmbeddedSchemaVersion<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_date_published: Option<EmbeddedSdDatePublished<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_license: Option<EmbeddedSdLicense<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_publisher: Option<EmbeddedSdPublisher<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<EmbeddedSize<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_organization: Option<EmbeddedSourceOrganization<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spatial: Option<EmbeddedSpatial<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spatial_coverage: Option<EmbeddedSpatialCoverage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sponsor: Option<EmbeddedSponsor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub step: Option<EmbeddedStep<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub steps: Option<EmbeddedSteps<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject_of: Option<EmbeddedSubjectOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suitable_for_diet: Option<EmbeddedSuitableForDiet<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supply: Option<EmbeddedSupply<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub teaches: Option<EmbeddedTeaches<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temporal: Option<EmbeddedTemporal<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temporal_coverage: Option<EmbeddedTemporalCoverage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub text: Option<EmbeddedText<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thumbnail: Option<EmbeddedThumbnail<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thumbnail_url: Option<EmbeddedThumbnailUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time_required: Option<EmbeddedTimeRequired<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool: Option<EmbeddedTool<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_time: Option<EmbeddedTotalTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation_of_work: Option<EmbeddedTranslationOfWork<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translator: Option<EmbeddedTranslator<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub typical_age_range: Option<EmbeddedTypicalAgeRange<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<EmbeddedUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub usage_info: Option<EmbeddedUsageInfo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<EmbeddedVersion<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub video: Option<EmbeddedVideo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub word_count: Option<EmbeddedWordCount<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_example: Option<EmbeddedWorkExample<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_translation: Option<EmbeddedWorkTranslation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#yield: Option<EmbeddedYield<S>>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAbout<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAbstract<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAccessMode<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAccessModeSufficient<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAccessibilityApi<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAccessibilityControl<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAccessibilityFeature<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAccessibilityHazard<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAccessibilitySummary<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAccountablePerson<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAcquireLicensePage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAdditionalType<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAggregateRating<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAlternateName<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAlternativeHeadline<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedArchivedAt<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAssesses<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAssociatedMedia<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAudience<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAudio<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAuthor<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAward<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedAwards<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCharacter<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCitation<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedComment<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCommentCount<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedConditionsOfAccess<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedContentLocation<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedContentRating<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedContentReferenceTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedContributor<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCookTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCookingMethod<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCopyrightHolder<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCopyrightNotice<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCopyrightYear<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCorrection<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCountryOfOrigin<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCreativeWorkStatus<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCreator<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedCreditText<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedDateCreated<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedDateModified<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedDatePublished<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedDescription<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedDigitalSourceType<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedDisambiguatingDescription<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedDiscussionUrl<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEditEidr<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEditor<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEducationalAlignment<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEducationalLevel<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEducationalUse<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEncoding<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEncodingFormat<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEncodings<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedEstimatedCost<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedExampleOfWork<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedExpires<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedFileFormat<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedFunder<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedFunding<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedGenre<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedHasPart<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedHeadline<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedIdentifier<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedImage<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.ImageObject#embedded")]
    ImageObjectEmbedded(Box<image_object::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedInLanguage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedIngredients<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedInteractionStatistic<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedInteractivityType<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedInterpretedAsClaim<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedIsAccessibleForFree<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedIsBasedOn<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Product#embedded")]
    ProductEmbedded(Box<product::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedIsBasedOnUrl<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Product#embedded")]
    ProductEmbedded(Box<product::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedIsFamilyFriendly<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedIsPartOf<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedKeywords<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedLearningResourceType<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedLicense<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedLocationCreated<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedMainEntity<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedMainEntityOfPage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedMaintainer<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedMaterial<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Product#embedded")]
    ProductEmbedded(Box<product::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedMaterialExtent<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedMentions<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedName<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedNutrition<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedOffers<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Offer#embedded")]
    OfferEmbedded(Box<offer::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPattern<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPerformTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPosition<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPotentialAction<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPrepTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedProducer<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedProvider<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPublication<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPublisher<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPublisherImprint<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedPublishingPrinciples<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedRecipeCategory<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedRecipeCuisine<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedRecipeIngredient<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedRecipeInstructions<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedRecipeYield<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedRecordedAt<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Event#embedded")]
    EventEmbedded(Box<event::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedReleasedEvent<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedReview<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedReviews<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSameAs<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSchemaVersion<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSdDatePublished<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSdLicense<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSdPublisher<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSize<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSourceOrganization<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSpatial<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSpatialCoverage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSponsor<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedStep<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSteps<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSubjectOf<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Event#embedded")]
    EventEmbedded(Box<event::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSuitableForDiet<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedSupply<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTeaches<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTemporal<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTemporalCoverage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedText<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedThumbnail<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.ImageObject#embedded")]
    ImageObjectEmbedded(Box<image_object::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedThumbnailUrl<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTimeRequired<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTool<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTotalTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTranslationOfWork<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTranslator<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedTypicalAgeRange<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedUrl<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedUsageInfo<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedVersion<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedVideo<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedWordCount<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedWorkExample<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedWorkTranslation<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EmbeddedYield<S: BosStr = DefaultStr> {}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(
    rename_all = "camelCase",
    rename = "social.flockfeeds.lexical.type.Recipe",
    tag = "$type",
    bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Recipe<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub about: Option<RecipeAbout<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#abstract: Option<RecipeAbstract<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub access_mode: Option<RecipeAccessMode<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub access_mode_sufficient: Option<RecipeAccessModeSufficient<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_api: Option<RecipeAccessibilityApi<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_control: Option<RecipeAccessibilityControl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_feature: Option<RecipeAccessibilityFeature<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_hazard: Option<RecipeAccessibilityHazard<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_summary: Option<RecipeAccessibilitySummary<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accountable_person: Option<RecipeAccountablePerson<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub acquire_license_page: Option<RecipeAcquireLicensePage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_type: Option<RecipeAdditionalType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aggregate_rating: Option<RecipeAggregateRating<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternate_name: Option<RecipeAlternateName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternative_headline: Option<RecipeAlternativeHeadline<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub archived_at: Option<RecipeArchivedAt<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub assesses: Option<RecipeAssesses<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub associated_media: Option<RecipeAssociatedMedia<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audience: Option<RecipeAudience<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audio: Option<RecipeAudio<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub author: Option<RecipeAuthor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub award: Option<RecipeAward<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awards: Option<RecipeAwards<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub character: Option<RecipeCharacter<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub citation: Option<RecipeCitation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<RecipeComment<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment_count: Option<RecipeCommentCount<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conditions_of_access: Option<RecipeConditionsOfAccess<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_location: Option<RecipeContentLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_rating: Option<RecipeContentRating<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_reference_time: Option<RecipeContentReferenceTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contributor: Option<RecipeContributor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cook_time: Option<RecipeCookTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cooking_method: Option<RecipeCookingMethod<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_holder: Option<RecipeCopyrightHolder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_notice: Option<RecipeCopyrightNotice<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_year: Option<RecipeCopyrightYear<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correction: Option<RecipeCorrection<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_of_origin: Option<RecipeCountryOfOrigin<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creative_work_status: Option<RecipeCreativeWorkStatus<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creator: Option<RecipeCreator<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub credit_text: Option<RecipeCreditText<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_created: Option<RecipeDateCreated<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_modified: Option<RecipeDateModified<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_published: Option<RecipeDatePublished<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<RecipeDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digital_source_type: Option<RecipeDigitalSourceType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disambiguating_description: Option<RecipeDisambiguatingDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub discussion_url: Option<RecipeDiscussionUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_eidr: Option<RecipeEditEidr<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor: Option<RecipeEditor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_alignment: Option<RecipeEducationalAlignment<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_level: Option<RecipeEducationalLevel<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_use: Option<RecipeEducationalUse<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding: Option<RecipeEncoding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding_format: Option<RecipeEncodingFormat<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encodings: Option<RecipeEncodings<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub estimated_cost: Option<RecipeEstimatedCost<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub example_of_work: Option<RecipeExampleOfWork<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires: Option<RecipeExpires<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_format: Option<RecipeFileFormat<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funder: Option<RecipeFunder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funding: Option<RecipeFunding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub genre: Option<RecipeGenre<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_part: Option<RecipeHasPart<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub headline: Option<RecipeHeadline<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifier: Option<RecipeIdentifier<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<RecipeImage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub in_language: Option<RecipeInLanguage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ingredients: Option<RecipeIngredients<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interaction_statistic: Option<RecipeInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interactivity_type: Option<RecipeInteractivityType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpreted_as_claim: Option<RecipeInterpretedAsClaim<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_accessible_for_free: Option<RecipeIsAccessibleForFree<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_based_on: Option<RecipeIsBasedOn<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_based_on_url: Option<RecipeIsBasedOnUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_family_friendly: Option<RecipeIsFamilyFriendly<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_part_of: Option<RecipeIsPartOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub keywords: Option<RecipeKeywords<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub learning_resource_type: Option<RecipeLearningResourceType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub license: Option<RecipeLicense<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_created: Option<RecipeLocationCreated<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity: Option<RecipeMainEntity<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity_of_page: Option<RecipeMainEntityOfPage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maintainer: Option<RecipeMaintainer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub material: Option<RecipeMaterial<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub material_extent: Option<RecipeMaterialExtent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mentions: Option<RecipeMentions<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<RecipeName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nutrition: Option<RecipeNutrition<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offers: Option<RecipeOffers<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<RecipePattern<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub perform_time: Option<RecipePerformTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub position: Option<RecipePosition<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub potential_action: Option<RecipePotentialAction<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prep_time: Option<RecipePrepTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub producer: Option<RecipeProducer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<RecipeProvider<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publication: Option<RecipePublication<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher: Option<RecipePublisher<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher_imprint: Option<RecipePublisherImprint<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publishing_principles: Option<RecipePublishingPrinciples<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_category: Option<RecipeRecipeCategory<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_cuisine: Option<RecipeRecipeCuisine<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_ingredient: Option<RecipeRecipeIngredient<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_instructions: Option<RecipeRecipeInstructions<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recipe_yield: Option<RecipeRecipeYield<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recorded_at: Option<RecipeRecordedAt<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub released_event: Option<RecipeReleasedEvent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub review: Option<RecipeReview<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reviews: Option<RecipeReviews<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub same_as: Option<RecipeSameAs<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub schema_version: Option<RecipeSchemaVersion<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_date_published: Option<RecipeSdDatePublished<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_license: Option<RecipeSdLicense<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_publisher: Option<RecipeSdPublisher<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<RecipeSize<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_organization: Option<RecipeSourceOrganization<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spatial: Option<RecipeSpatial<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spatial_coverage: Option<RecipeSpatialCoverage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sponsor: Option<RecipeSponsor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub step: Option<RecipeStep<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub steps: Option<RecipeSteps<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject_of: Option<RecipeSubjectOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suitable_for_diet: Option<RecipeSuitableForDiet<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supply: Option<RecipeSupply<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub teaches: Option<RecipeTeaches<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temporal: Option<RecipeTemporal<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temporal_coverage: Option<RecipeTemporalCoverage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub text: Option<RecipeText<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thumbnail: Option<RecipeThumbnail<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thumbnail_url: Option<RecipeThumbnailUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time_required: Option<RecipeTimeRequired<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool: Option<RecipeTool<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_time: Option<RecipeTotalTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation_of_work: Option<RecipeTranslationOfWork<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translator: Option<RecipeTranslator<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub typical_age_range: Option<RecipeTypicalAgeRange<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<RecipeUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub usage_info: Option<RecipeUsageInfo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<RecipeVersion<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub video: Option<RecipeVideo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub word_count: Option<RecipeWordCount<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_example: Option<RecipeWorkExample<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_translation: Option<RecipeWorkTranslation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#yield: Option<RecipeYield<S>>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAbout<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAbstract<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAccessMode<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAccessModeSufficient<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAccessibilityApi<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAccessibilityControl<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAccessibilityFeature<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAccessibilityHazard<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAccessibilitySummary<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAccountablePerson<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAcquireLicensePage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAdditionalType<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAggregateRating<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAlternateName<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAlternativeHeadline<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeArchivedAt<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAssesses<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAssociatedMedia<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAudience<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAudio<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAuthor<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAward<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeAwards<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCharacter<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCitation<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeComment<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCommentCount<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeConditionsOfAccess<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeContentLocation<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeContentRating<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeContentReferenceTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeContributor<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCookTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCookingMethod<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCopyrightHolder<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCopyrightNotice<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCopyrightYear<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCorrection<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCountryOfOrigin<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCreativeWorkStatus<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCreator<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeCreditText<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeDateCreated<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeDateModified<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeDatePublished<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeDescription<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeDigitalSourceType<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeDisambiguatingDescription<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeDiscussionUrl<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEditEidr<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEditor<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEducationalAlignment<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEducationalLevel<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEducationalUse<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEncoding<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEncodingFormat<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEncodings<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeEstimatedCost<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeExampleOfWork<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeExpires<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeFileFormat<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeFunder<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeFunding<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeGenre<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeHasPart<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeHeadline<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeIdentifier<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeImage<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.ImageObject#embedded")]
    ImageObjectEmbedded(Box<image_object::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeInLanguage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeIngredients<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeInteractionStatistic<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeInteractivityType<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeInterpretedAsClaim<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeIsAccessibleForFree<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeIsBasedOn<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Product#embedded")]
    ProductEmbedded(Box<product::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeIsBasedOnUrl<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Product#embedded")]
    ProductEmbedded(Box<product::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeIsFamilyFriendly<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeIsPartOf<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeKeywords<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeLearningResourceType<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeLicense<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeLocationCreated<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeMainEntity<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeMainEntityOfPage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeMaintainer<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeMaterial<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Product#embedded")]
    ProductEmbedded(Box<product::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeMaterialExtent<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeMentions<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeName<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeNutrition<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeOffers<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Offer#embedded")]
    OfferEmbedded(Box<offer::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePattern<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePerformTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePosition<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePotentialAction<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePrepTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeProducer<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeProvider<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePublication<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePublisher<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePublisherImprint<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipePublishingPrinciples<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeRecipeCategory<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeRecipeCuisine<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeRecipeIngredient<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeRecipeInstructions<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeRecipeYield<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeRecordedAt<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Event#embedded")]
    EventEmbedded(Box<event::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeReleasedEvent<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeReview<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeReviews<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSameAs<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSchemaVersion<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSdDatePublished<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSdLicense<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSdPublisher<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSize<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSourceOrganization<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSpatial<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSpatialCoverage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSponsor<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeStep<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSteps<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSubjectOf<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Event#embedded")]
    EventEmbedded(Box<event::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSuitableForDiet<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeSupply<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTeaches<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTemporal<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTemporalCoverage<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeText<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeThumbnail<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.ImageObject#embedded")]
    ImageObjectEmbedded(Box<image_object::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeThumbnailUrl<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTimeRequired<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTool<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTotalTime<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTranslationOfWork<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTranslator<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.Organization#embedded")]
    OrganizationEmbedded(Box<organization::Embedded<S>>),
    #[serde(rename = "social.flockfeeds.lexical.type.Person#embedded")]
    PersonEmbedded(Box<person::Embedded<S>>),
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeTypicalAgeRange<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeUrl<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeUsageInfo<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeVersion<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeVideo<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeWordCount<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeWorkExample<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeWorkTranslation<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum RecipeYield<S: BosStr = DefaultStr> {}
/// Typed wrapper for GetRecord response with this collection's record type.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct RecipeGetRecordOutput<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cid: Option<Cid<S>>,
    pub uri: AtUri<S>,
    pub value: Recipe<S>,
}

impl<S: BosStr> Recipe<S> {
    pub fn uri(uri: S) -> Result<RecordUri<S, RecipeRecord>, UriError> {
        RecordUri::try_from_uri(AtUri::new(uri)?)
    }
}

impl<S: BosStr> LexiconSchema for Embedded<S> {
    fn nsid() -> &'static str {
        "social.flockfeeds.lexical.type.Recipe"
    }
    fn def_name() -> &'static str {
        "embedded"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_social_flockfeeds_lexical_type_Recipe()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

/// Marker type for deserializing records from this collection.

#[derive(Debug, Serialize, Deserialize)]
pub struct RecipeRecord;
impl XrpcResp for RecipeRecord {
    const NSID: &'static str = "social.flockfeeds.lexical.type.Recipe";
    const ENCODING: &'static str = "application/json";
    type Output<S: BosStr> = RecipeGetRecordOutput<S>;
    type Err = RecordError;
}

impl<S: BosStr> From<RecipeGetRecordOutput<S>> for Recipe<S> {
    fn from(output: RecipeGetRecordOutput<S>) -> Self {
        output.value
    }
}

impl<S: BosStr> Collection for Recipe<S> {
    const NSID: &'static str = "social.flockfeeds.lexical.type.Recipe";
    type Record = RecipeRecord;
}

impl Collection for RecipeRecord {
    const NSID: &'static str = "social.flockfeeds.lexical.type.Recipe";
    type Record = RecipeRecord;
}

impl<S: BosStr> LexiconSchema for Recipe<S> {
    fn nsid() -> &'static str {
        "social.flockfeeds.lexical.type.Recipe"
    }
    fn def_name() -> &'static str {
        "main"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_social_flockfeeds_lexical_type_Recipe()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

fn lexicon_doc_social_flockfeeds_lexical_type_Recipe() -> LexiconDoc<'static> {
    #[allow(unused_imports)]
    use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
    use jacquard_lexicon::lexicon::*;
    use alloc::collections::BTreeMap;
    LexiconDoc {
        lexicon: Lexicon::Lexicon1,
        id: CowStr::new_static("social.flockfeeds.lexical.type.Recipe"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("embedded"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "A recipe. For dietary restrictions covered by the recipe, a few common restrictions are enumerated via [[suitableForDiet]]. The [[keywords]] property can also be used to add more detail.",
                        ),
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("about"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Thing#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#aboutList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("abstract"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#abstractScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#abstractList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessMode"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessModeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessModeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessModeSufficient"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessModeSufficientList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityAPI"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityAPIScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityAPIList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityControl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityControlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityControlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityFeature"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityFeatureScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityFeatureList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityHazard"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityHazardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityHazardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilitySummary"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilitySummaryScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilitySummaryList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accountablePerson"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accountablePersonList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("acquireLicensePage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#acquireLicensePageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#acquireLicensePageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("additionalType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#additionalTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#additionalTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("aggregateRating"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.AggregateRating#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#aggregateRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternateName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#alternateNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#alternateNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternativeHeadline"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#alternativeHeadlineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#alternativeHeadlineList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("archivedAt"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.WebPage#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#archivedAtScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#archivedAtList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("assesses"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#assessesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#assessesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("associatedMedia"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MediaObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#associatedMediaList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("audience"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Audience#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#audienceList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("audio"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.AudioObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Clip#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.MusicRecording#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#audioList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("author"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#authorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("award"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#awardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#awardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("awards"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#awardsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#awardsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("character"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#characterList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("citation"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#citationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#citationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("comment"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Comment#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#commentList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("commentCount"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#commentCountScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#commentCountList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("conditionsOfAccess"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#conditionsOfAccessScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#conditionsOfAccessList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contentLocation"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentLocationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contentRating"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Rating#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentRatingScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contentReferenceTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentReferenceTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentReferenceTimeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contributor"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contributorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("cookTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#cookTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#cookTimeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("cookingMethod"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#cookingMethodScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#cookingMethodList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightHolder"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightHolderList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightNotice"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightNoticeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightNoticeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightYear"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightYearScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightYearList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("correction"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CorrectionComment#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#correctionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#correctionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("countryOfOrigin"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Country#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#countryOfOriginList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("creativeWorkStatus"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creativeWorkStatusScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creativeWorkStatusList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("creator"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creatorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("creditText"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creditTextScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creditTextList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dateCreated"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#dateCreatedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#dateCreatedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dateModified"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#dateModifiedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#dateModifiedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("datePublished"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#datePublishedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#datePublishedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("description"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.TextObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#descriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#descriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("digitalSourceType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.IPTCDigitalSourceEnumeration#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#digitalSourceTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#digitalSourceTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("disambiguatingDescription"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#disambiguatingDescriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#disambiguatingDescriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("discussionUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#discussionUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#discussionUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("editEIDR"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#editEIDRScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#editEIDRList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("editor"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#editorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("educationalAlignment"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.AlignmentObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalAlignmentList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("educationalLevel"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalLevelScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalLevelList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("educationalUse"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalUseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalUseList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("encoding"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MediaObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#encodingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("encodingFormat"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#encodingFormatScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#encodingFormatList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("encodings"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MediaObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#encodingsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("estimatedCost"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MonetaryAmount#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#estimatedCostScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#estimatedCostList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("exampleOfWork"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#exampleOfWorkList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("expires"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#expiresScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#expiresList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("fileFormat"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#fileFormatScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#fileFormatList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("funder"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#funderList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("funding"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Grant#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#fundingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("genre"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#genreScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#genreList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasPart"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#hasPartList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("headline"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#headlineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#headlineList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("identifier"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PropertyValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#identifierScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#identifierList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("image"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#imageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#imageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("inLanguage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Language#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#inLanguageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#inLanguageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("ingredients"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#ingredientsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#ingredientsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("interactionStatistic"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.InteractionCounter#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#interactionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("interactivityType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#interactivityTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#interactivityTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("interpretedAsClaim"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Claim#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#interpretedAsClaimList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isAccessibleForFree"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isAccessibleForFreeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isAccessibleForFreeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isBasedOn"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Product#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isBasedOnScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isBasedOnList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isBasedOnUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Product#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isBasedOnUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isBasedOnUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isFamilyFriendly"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isFamilyFriendlyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isFamilyFriendlyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isPartOf"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isPartOfScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isPartOfList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("keywords"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#keywordsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#keywordsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("learningResourceType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#learningResourceTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#learningResourceTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("license"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#licenseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#licenseList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("locationCreated"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#locationCreatedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("mainEntity"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Thing#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#mainEntityList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("mainEntityOfPage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#mainEntityOfPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#mainEntityOfPageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("maintainer"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#maintainerList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("material"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Product#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#materialScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#materialList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("materialExtent"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#materialExtentScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#materialExtentList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("mentions"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Thing#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#mentionsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#nameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#nameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("nutrition"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.NutritionInformation#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#nutritionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("offers"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Demand#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Offer#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#offersList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("pattern"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#patternScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#patternList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("performTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#performTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#performTimeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("position"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#positionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#positionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("potentialAction"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Action#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#potentialActionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("prepTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#prepTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#prepTimeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("producer"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#producerList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("provider"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#providerList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("publication"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PublicationEvent#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publicationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("publisher"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publisherList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("publisherImprint"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publisherImprintList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("publishingPrinciples"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publishingPrinciplesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publishingPrinciplesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("recipeCategory"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeCategoryScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeCategoryList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("recipeCuisine"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeCuisineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeCuisineList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("recipeIngredient"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.PropertyValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeIngredientScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeIngredientList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("recipeInstructions"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeInstructionsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeInstructionsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("recipeYield"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeYieldScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeYieldList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("recordedAt"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recordedAtList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("releasedEvent"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PublicationEvent#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#releasedEventList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("review"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Review#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#reviewList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("reviews"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Review#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#reviewsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sameAs"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sameAsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sameAsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("schemaVersion"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#schemaVersionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#schemaVersionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sdDatePublished"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdDatePublishedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdDatePublishedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sdLicense"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdLicenseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdLicenseList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sdPublisher"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdPublisherList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("size"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.SizeSpecification#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sizeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sizeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sourceOrganization"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sourceOrganizationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("spatial"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#spatialList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("spatialCoverage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#spatialCoverageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sponsor"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sponsorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("step"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.HowToSection#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.HowToStep#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#stepScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#stepList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("steps"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#stepsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#stepsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("subjectOf"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#subjectOfList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("suitableForDiet"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.RestrictedDiet#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#suitableForDietScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#suitableForDietList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("supply"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.HowToSupply#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#supplyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#supplyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("teaches"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#teachesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#teachesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("temporal"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#temporalScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#temporalList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("temporalCoverage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#temporalCoverageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#temporalCoverageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("text"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#textScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#textList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("thumbnail"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#thumbnailList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("thumbnailUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#thumbnailUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#thumbnailUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("timeRequired"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#timeRequiredScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#timeRequiredList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("tool"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.HowToTool#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#toolScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#toolList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("totalTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#totalTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#totalTimeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("translationOfWork"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#translationOfWorkList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("translator"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#translatorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("typicalAgeRange"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#typicalAgeRangeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#typicalAgeRangeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("url"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#urlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#urlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("usageInfo"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#usageInfoScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#usageInfoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("version"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#versionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#versionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("video"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Clip#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.VideoObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#videoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("wordCount"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#wordCountScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#wordCountList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("workExample"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#workExampleList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("workTranslation"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#workTranslationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("yield"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#yieldScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.recipe#yieldList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("main"),
                LexUserType::Record(LexRecord {
                    key: Some(CowStr::new_static("tid")),
                    record: LexRecordRecord::Object(LexObject {
                        description: Some(
                            CowStr::new_static(
                                "A recipe. For dietary restrictions covered by the recipe, a few common restrictions are enumerated via [[suitableForDiet]]. The [[keywords]] property can also be used to add more detail.",
                            ),
                        ),
                        properties: {
                            #[allow(unused_mut)]
                            let mut map = BTreeMap::new();
                            map.insert(
                                SmolStr::new_static("about"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Thing#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#aboutList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("abstract"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#abstractScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#abstractList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessMode"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessModeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessModeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessModeSufficient"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessModeSufficientList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilityAPI"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityAPIScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityAPIList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilityControl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityControlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityControlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilityFeature"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityFeatureScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityFeatureList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilityHazard"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityHazardScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilityHazardList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilitySummary"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilitySummaryScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accessibilitySummaryList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accountablePerson"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#accountablePersonList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("acquireLicensePage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#acquireLicensePageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#acquireLicensePageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("additionalType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#additionalTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#additionalTypeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("aggregateRating"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.AggregateRating#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#aggregateRatingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alternateName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#alternateNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#alternateNameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alternativeHeadline"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#alternativeHeadlineScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#alternativeHeadlineList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("archivedAt"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.WebPage#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#archivedAtScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#archivedAtList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("assesses"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#assessesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#assessesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("associatedMedia"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MediaObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#associatedMediaList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("audience"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Audience#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#audienceList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("audio"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.AudioObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Clip#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.MusicRecording#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#audioList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("author"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#authorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("award"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#awardScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#awardList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("awards"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#awardsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#awardsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("character"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#characterList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("citation"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#citationScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#citationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("comment"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Comment#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#commentList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("commentCount"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#commentCountScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#commentCountList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("conditionsOfAccess"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#conditionsOfAccessScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#conditionsOfAccessList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contentLocation"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentLocationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contentRating"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Rating#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentRatingScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentRatingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contentReferenceTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentReferenceTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contentReferenceTimeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contributor"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#contributorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("cookTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#cookTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#cookTimeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("cookingMethod"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#cookingMethodScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#cookingMethodList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("copyrightHolder"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightHolderList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("copyrightNotice"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightNoticeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightNoticeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("copyrightYear"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightYearScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#copyrightYearList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("correction"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CorrectionComment#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#correctionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#correctionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("countryOfOrigin"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Country#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#countryOfOriginList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("creativeWorkStatus"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creativeWorkStatusScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creativeWorkStatusList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("creator"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creatorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("creditText"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creditTextScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#creditTextList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("dateCreated"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#dateCreatedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#dateCreatedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("dateModified"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#dateModifiedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#dateModifiedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("datePublished"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#datePublishedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#datePublishedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("description"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.TextObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#descriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#descriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("digitalSourceType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.IPTCDigitalSourceEnumeration#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#digitalSourceTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#digitalSourceTypeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("disambiguatingDescription"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#disambiguatingDescriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#disambiguatingDescriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("discussionUrl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#discussionUrlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#discussionUrlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("editEIDR"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#editEIDRScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#editEIDRList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("editor"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#editorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("educationalAlignment"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.AlignmentObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalAlignmentList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("educationalLevel"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalLevelScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalLevelList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("educationalUse"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalUseScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#educationalUseList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("encoding"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MediaObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#encodingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("encodingFormat"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#encodingFormatScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#encodingFormatList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("encodings"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MediaObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#encodingsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("estimatedCost"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MonetaryAmount#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#estimatedCostScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#estimatedCostList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("exampleOfWork"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#exampleOfWorkList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("expires"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#expiresScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#expiresList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("fileFormat"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#fileFormatScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#fileFormatList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("funder"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#funderList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("funding"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Grant#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#fundingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("genre"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#genreScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#genreList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasPart"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#hasPartList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("headline"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#headlineScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#headlineList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("identifier"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.PropertyValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#identifierScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#identifierList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("image"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#imageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#imageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("inLanguage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Language#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#inLanguageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#inLanguageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("ingredients"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#ingredientsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#ingredientsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("interactionStatistic"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.InteractionCounter#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#interactionStatisticList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("interactivityType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#interactivityTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#interactivityTypeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("interpretedAsClaim"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Claim#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#interpretedAsClaimList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isAccessibleForFree"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isAccessibleForFreeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isAccessibleForFreeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isBasedOn"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Product#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isBasedOnScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isBasedOnList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isBasedOnUrl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Product#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isBasedOnUrlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isBasedOnUrlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isFamilyFriendly"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isFamilyFriendlyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isFamilyFriendlyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isPartOf"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isPartOfScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#isPartOfList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("keywords"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#keywordsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#keywordsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("learningResourceType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#learningResourceTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#learningResourceTypeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("license"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#licenseScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#licenseList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("locationCreated"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#locationCreatedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("mainEntity"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Thing#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#mainEntityList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("mainEntityOfPage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#mainEntityOfPageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#mainEntityOfPageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("maintainer"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#maintainerList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("material"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Product#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#materialScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#materialList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("materialExtent"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#materialExtentScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#materialExtentList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("mentions"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Thing#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#mentionsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("name"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#nameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#nameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("nutrition"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.NutritionInformation#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#nutritionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("offers"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Demand#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Offer#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#offersList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("pattern"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#patternScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#patternList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("performTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#performTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#performTimeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("position"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#positionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#positionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("potentialAction"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Action#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#potentialActionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("prepTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#prepTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#prepTimeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("producer"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#producerList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("provider"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#providerList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("publication"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.PublicationEvent#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publicationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("publisher"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publisherList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("publisherImprint"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publisherImprintList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("publishingPrinciples"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publishingPrinciplesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#publishingPrinciplesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("recipeCategory"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeCategoryScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeCategoryList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("recipeCuisine"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeCuisineScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeCuisineList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("recipeIngredient"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.PropertyValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeIngredientScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeIngredientList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("recipeInstructions"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeInstructionsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeInstructionsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("recipeYield"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeYieldScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recipeYieldList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("recordedAt"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#recordedAtList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("releasedEvent"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.PublicationEvent#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#releasedEventList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("review"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Review#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#reviewList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("reviews"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Review#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#reviewsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sameAs"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sameAsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sameAsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("schemaVersion"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#schemaVersionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#schemaVersionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sdDatePublished"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdDatePublishedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdDatePublishedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sdLicense"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdLicenseScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdLicenseList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sdPublisher"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sdPublisherList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("size"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.SizeSpecification#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sizeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sizeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sourceOrganization"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sourceOrganizationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("spatial"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#spatialList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("spatialCoverage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#spatialCoverageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sponsor"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#sponsorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("step"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.HowToSection#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.HowToStep#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#stepScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#stepList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("steps"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#stepsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#stepsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("subjectOf"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#subjectOfList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("suitableForDiet"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.RestrictedDiet#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#suitableForDietScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#suitableForDietList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("supply"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.HowToSupply#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#supplyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#supplyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("teaches"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#teachesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#teachesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("temporal"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#temporalScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#temporalList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("temporalCoverage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#temporalCoverageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#temporalCoverageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("text"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#textScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#textList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("thumbnail"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#thumbnailList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("thumbnailUrl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#thumbnailUrlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#thumbnailUrlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("timeRequired"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#timeRequiredScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#timeRequiredList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("tool"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.HowToTool#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#toolScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#toolList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("totalTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#totalTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#totalTimeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("translationOfWork"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#translationOfWorkList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("translator"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#translatorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("typicalAgeRange"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#typicalAgeRangeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#typicalAgeRangeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("url"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#urlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#urlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("usageInfo"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#usageInfoScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#usageInfoList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("version"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#versionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#versionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("video"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Clip#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.VideoObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#videoList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("wordCount"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#wordCountScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#wordCountList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("workExample"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#workExampleList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("workTranslation"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#workTranslationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("yield"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#yieldScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.recipe#yieldList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map
                        },
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}

pub mod recipe_state {

    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
    #[allow(unused)]
    use ::core::marker::PhantomData;
    mod sealed {
        pub trait Sealed {}
    }
    /// State trait tracking which required fields have been set
    pub trait State: sealed::Sealed {}
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {}
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {}
}

/// Builder for constructing an instance of this type.
pub struct RecipeBuilder<St: recipe_state::State, S: BosStr = DefaultStr> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<RecipeAbout<S>>,
        Option<RecipeAbstract<S>>,
        Option<RecipeAccessMode<S>>,
        Option<RecipeAccessModeSufficient<S>>,
        Option<RecipeAccessibilityApi<S>>,
        Option<RecipeAccessibilityControl<S>>,
        Option<RecipeAccessibilityFeature<S>>,
        Option<RecipeAccessibilityHazard<S>>,
        Option<RecipeAccessibilitySummary<S>>,
        Option<RecipeAccountablePerson<S>>,
        Option<RecipeAcquireLicensePage<S>>,
        Option<RecipeAdditionalType<S>>,
        Option<RecipeAggregateRating<S>>,
        Option<RecipeAlternateName<S>>,
        Option<RecipeAlternativeHeadline<S>>,
        Option<RecipeArchivedAt<S>>,
        Option<RecipeAssesses<S>>,
        Option<RecipeAssociatedMedia<S>>,
        Option<RecipeAudience<S>>,
        Option<RecipeAudio<S>>,
        Option<RecipeAuthor<S>>,
        Option<RecipeAward<S>>,
        Option<RecipeAwards<S>>,
        Option<RecipeCharacter<S>>,
        Option<RecipeCitation<S>>,
        Option<RecipeComment<S>>,
        Option<RecipeCommentCount<S>>,
        Option<RecipeConditionsOfAccess<S>>,
        Option<RecipeContentLocation<S>>,
        Option<RecipeContentRating<S>>,
        Option<RecipeContentReferenceTime<S>>,
        Option<RecipeContributor<S>>,
        Option<RecipeCookTime<S>>,
        Option<RecipeCookingMethod<S>>,
        Option<RecipeCopyrightHolder<S>>,
        Option<RecipeCopyrightNotice<S>>,
        Option<RecipeCopyrightYear<S>>,
        Option<RecipeCorrection<S>>,
        Option<RecipeCountryOfOrigin<S>>,
        Option<RecipeCreativeWorkStatus<S>>,
        Option<RecipeCreator<S>>,
        Option<RecipeCreditText<S>>,
        Option<RecipeDateCreated<S>>,
        Option<RecipeDateModified<S>>,
        Option<RecipeDatePublished<S>>,
        Option<RecipeDescription<S>>,
        Option<RecipeDigitalSourceType<S>>,
        Option<RecipeDisambiguatingDescription<S>>,
        Option<RecipeDiscussionUrl<S>>,
        Option<RecipeEditEidr<S>>,
        Option<RecipeEditor<S>>,
        Option<RecipeEducationalAlignment<S>>,
        Option<RecipeEducationalLevel<S>>,
        Option<RecipeEducationalUse<S>>,
        Option<RecipeEncoding<S>>,
        Option<RecipeEncodingFormat<S>>,
        Option<RecipeEncodings<S>>,
        Option<RecipeEstimatedCost<S>>,
        Option<RecipeExampleOfWork<S>>,
        Option<RecipeExpires<S>>,
        Option<RecipeFileFormat<S>>,
        Option<RecipeFunder<S>>,
        Option<RecipeFunding<S>>,
        Option<RecipeGenre<S>>,
        Option<RecipeHasPart<S>>,
        Option<RecipeHeadline<S>>,
        Option<RecipeIdentifier<S>>,
        Option<RecipeImage<S>>,
        Option<RecipeInLanguage<S>>,
        Option<RecipeIngredients<S>>,
        Option<RecipeInteractionStatistic<S>>,
        Option<RecipeInteractivityType<S>>,
        Option<RecipeInterpretedAsClaim<S>>,
        Option<RecipeIsAccessibleForFree<S>>,
        Option<RecipeIsBasedOn<S>>,
        Option<RecipeIsBasedOnUrl<S>>,
        Option<RecipeIsFamilyFriendly<S>>,
        Option<RecipeIsPartOf<S>>,
        Option<RecipeKeywords<S>>,
        Option<RecipeLearningResourceType<S>>,
        Option<RecipeLicense<S>>,
        Option<RecipeLocationCreated<S>>,
        Option<RecipeMainEntity<S>>,
        Option<RecipeMainEntityOfPage<S>>,
        Option<RecipeMaintainer<S>>,
        Option<RecipeMaterial<S>>,
        Option<RecipeMaterialExtent<S>>,
        Option<RecipeMentions<S>>,
        Option<RecipeName<S>>,
        Option<RecipeNutrition<S>>,
        Option<RecipeOffers<S>>,
        Option<RecipePattern<S>>,
        Option<RecipePerformTime<S>>,
        Option<RecipePosition<S>>,
        Option<RecipePotentialAction<S>>,
        Option<RecipePrepTime<S>>,
        Option<RecipeProducer<S>>,
        Option<RecipeProvider<S>>,
        Option<RecipePublication<S>>,
        Option<RecipePublisher<S>>,
        Option<RecipePublisherImprint<S>>,
        Option<RecipePublishingPrinciples<S>>,
        Option<RecipeRecipeCategory<S>>,
        Option<RecipeRecipeCuisine<S>>,
        Option<RecipeRecipeIngredient<S>>,
        Option<RecipeRecipeInstructions<S>>,
        Option<RecipeRecipeYield<S>>,
        Option<RecipeRecordedAt<S>>,
        Option<RecipeReleasedEvent<S>>,
        Option<RecipeReview<S>>,
        Option<RecipeReviews<S>>,
        Option<RecipeSameAs<S>>,
        Option<RecipeSchemaVersion<S>>,
        Option<RecipeSdDatePublished<S>>,
        Option<RecipeSdLicense<S>>,
        Option<RecipeSdPublisher<S>>,
        Option<RecipeSize<S>>,
        Option<RecipeSourceOrganization<S>>,
        Option<RecipeSpatial<S>>,
        Option<RecipeSpatialCoverage<S>>,
        Option<RecipeSponsor<S>>,
        Option<RecipeStep<S>>,
        Option<RecipeSteps<S>>,
        Option<RecipeSubjectOf<S>>,
        Option<RecipeSuitableForDiet<S>>,
        Option<RecipeSupply<S>>,
        Option<RecipeTeaches<S>>,
        Option<RecipeTemporal<S>>,
        Option<RecipeTemporalCoverage<S>>,
        Option<RecipeText<S>>,
        Option<RecipeThumbnail<S>>,
        Option<RecipeThumbnailUrl<S>>,
        Option<RecipeTimeRequired<S>>,
        Option<RecipeTool<S>>,
        Option<RecipeTotalTime<S>>,
        Option<RecipeTranslationOfWork<S>>,
        Option<RecipeTranslator<S>>,
        Option<RecipeTypicalAgeRange<S>>,
        Option<RecipeUrl<S>>,
        Option<RecipeUsageInfo<S>>,
        Option<RecipeVersion<S>>,
        Option<RecipeVideo<S>>,
        Option<RecipeWordCount<S>>,
        Option<RecipeWorkExample<S>>,
        Option<RecipeWorkTranslation<S>>,
        Option<RecipeYield<S>>,
    ),
    _type: PhantomData<fn() -> S>,
}

impl Recipe<DefaultStr> {
    /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed
    pub fn new() -> RecipeBuilder<recipe_state::Empty, DefaultStr> {
        RecipeBuilder::new()
    }
}

impl<S: BosStr> Recipe<S> {
    /// Create a new builder for this type
    pub fn builder() -> RecipeBuilder<recipe_state::Empty, S> {
        RecipeBuilder::builder()
    }
}

impl RecipeBuilder<recipe_state::Empty, DefaultStr> {
    /// Create a new builder with all fields unset, using the default string type, if needed
    pub fn new() -> Self {
        RecipeBuilder {
            _state: PhantomData,
            _fields: (
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
            ),
            _type: PhantomData,
        }
    }
}

impl<S: BosStr> RecipeBuilder<recipe_state::Empty, S> {
    /// Create a new builder with all fields unset
    pub fn builder() -> Self {
        RecipeBuilder {
            _state: PhantomData,
            _fields: (
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
            ),
            _type: PhantomData,
        }
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `about` field (optional)
    pub fn about(mut self, value: impl Into<Option<RecipeAbout<S>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `about` field to an Option value (optional)
    pub fn maybe_about(mut self, value: Option<RecipeAbout<S>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `abstract` field (optional)
    pub fn r#abstract(mut self, value: impl Into<Option<RecipeAbstract<S>>>) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `abstract` field to an Option value (optional)
    pub fn maybe_abstract(mut self, value: Option<RecipeAbstract<S>>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `accessMode` field (optional)
    pub fn access_mode(mut self, value: impl Into<Option<RecipeAccessMode<S>>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `accessMode` field to an Option value (optional)
    pub fn maybe_access_mode(mut self, value: Option<RecipeAccessMode<S>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `accessModeSufficient` field (optional)
    pub fn access_mode_sufficient(
        mut self,
        value: impl Into<Option<RecipeAccessModeSufficient<S>>>,
    ) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `accessModeSufficient` field to an Option value (optional)
    pub fn maybe_access_mode_sufficient(
        mut self,
        value: Option<RecipeAccessModeSufficient<S>>,
    ) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `accessibilityAPI` field (optional)
    pub fn accessibility_api(
        mut self,
        value: impl Into<Option<RecipeAccessibilityApi<S>>>,
    ) -> Self {
        self._fields.4 = value.into();
        self
    }
    /// Set the `accessibilityAPI` field to an Option value (optional)
    pub fn maybe_accessibility_api(
        mut self,
        value: Option<RecipeAccessibilityApi<S>>,
    ) -> Self {
        self._fields.4 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `accessibilityControl` field (optional)
    pub fn accessibility_control(
        mut self,
        value: impl Into<Option<RecipeAccessibilityControl<S>>>,
    ) -> Self {
        self._fields.5 = value.into();
        self
    }
    /// Set the `accessibilityControl` field to an Option value (optional)
    pub fn maybe_accessibility_control(
        mut self,
        value: Option<RecipeAccessibilityControl<S>>,
    ) -> Self {
        self._fields.5 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `accessibilityFeature` field (optional)
    pub fn accessibility_feature(
        mut self,
        value: impl Into<Option<RecipeAccessibilityFeature<S>>>,
    ) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `accessibilityFeature` field to an Option value (optional)
    pub fn maybe_accessibility_feature(
        mut self,
        value: Option<RecipeAccessibilityFeature<S>>,
    ) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `accessibilityHazard` field (optional)
    pub fn accessibility_hazard(
        mut self,
        value: impl Into<Option<RecipeAccessibilityHazard<S>>>,
    ) -> Self {
        self._fields.7 = value.into();
        self
    }
    /// Set the `accessibilityHazard` field to an Option value (optional)
    pub fn maybe_accessibility_hazard(
        mut self,
        value: Option<RecipeAccessibilityHazard<S>>,
    ) -> Self {
        self._fields.7 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `accessibilitySummary` field (optional)
    pub fn accessibility_summary(
        mut self,
        value: impl Into<Option<RecipeAccessibilitySummary<S>>>,
    ) -> Self {
        self._fields.8 = value.into();
        self
    }
    /// Set the `accessibilitySummary` field to an Option value (optional)
    pub fn maybe_accessibility_summary(
        mut self,
        value: Option<RecipeAccessibilitySummary<S>>,
    ) -> Self {
        self._fields.8 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `accountablePerson` field (optional)
    pub fn accountable_person(
        mut self,
        value: impl Into<Option<RecipeAccountablePerson<S>>>,
    ) -> Self {
        self._fields.9 = value.into();
        self
    }
    /// Set the `accountablePerson` field to an Option value (optional)
    pub fn maybe_accountable_person(
        mut self,
        value: Option<RecipeAccountablePerson<S>>,
    ) -> Self {
        self._fields.9 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `acquireLicensePage` field (optional)
    pub fn acquire_license_page(
        mut self,
        value: impl Into<Option<RecipeAcquireLicensePage<S>>>,
    ) -> Self {
        self._fields.10 = value.into();
        self
    }
    /// Set the `acquireLicensePage` field to an Option value (optional)
    pub fn maybe_acquire_license_page(
        mut self,
        value: Option<RecipeAcquireLicensePage<S>>,
    ) -> Self {
        self._fields.10 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `additionalType` field (optional)
    pub fn additional_type(
        mut self,
        value: impl Into<Option<RecipeAdditionalType<S>>>,
    ) -> Self {
        self._fields.11 = value.into();
        self
    }
    /// Set the `additionalType` field to an Option value (optional)
    pub fn maybe_additional_type(
        mut self,
        value: Option<RecipeAdditionalType<S>>,
    ) -> Self {
        self._fields.11 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `aggregateRating` field (optional)
    pub fn aggregate_rating(
        mut self,
        value: impl Into<Option<RecipeAggregateRating<S>>>,
    ) -> Self {
        self._fields.12 = value.into();
        self
    }
    /// Set the `aggregateRating` field to an Option value (optional)
    pub fn maybe_aggregate_rating(
        mut self,
        value: Option<RecipeAggregateRating<S>>,
    ) -> Self {
        self._fields.12 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `alternateName` field (optional)
    pub fn alternate_name(
        mut self,
        value: impl Into<Option<RecipeAlternateName<S>>>,
    ) -> Self {
        self._fields.13 = value.into();
        self
    }
    /// Set the `alternateName` field to an Option value (optional)
    pub fn maybe_alternate_name(
        mut self,
        value: Option<RecipeAlternateName<S>>,
    ) -> Self {
        self._fields.13 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `alternativeHeadline` field (optional)
    pub fn alternative_headline(
        mut self,
        value: impl Into<Option<RecipeAlternativeHeadline<S>>>,
    ) -> Self {
        self._fields.14 = value.into();
        self
    }
    /// Set the `alternativeHeadline` field to an Option value (optional)
    pub fn maybe_alternative_headline(
        mut self,
        value: Option<RecipeAlternativeHeadline<S>>,
    ) -> Self {
        self._fields.14 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `archivedAt` field (optional)
    pub fn archived_at(mut self, value: impl Into<Option<RecipeArchivedAt<S>>>) -> Self {
        self._fields.15 = value.into();
        self
    }
    /// Set the `archivedAt` field to an Option value (optional)
    pub fn maybe_archived_at(mut self, value: Option<RecipeArchivedAt<S>>) -> Self {
        self._fields.15 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `assesses` field (optional)
    pub fn assesses(mut self, value: impl Into<Option<RecipeAssesses<S>>>) -> Self {
        self._fields.16 = value.into();
        self
    }
    /// Set the `assesses` field to an Option value (optional)
    pub fn maybe_assesses(mut self, value: Option<RecipeAssesses<S>>) -> Self {
        self._fields.16 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `associatedMedia` field (optional)
    pub fn associated_media(
        mut self,
        value: impl Into<Option<RecipeAssociatedMedia<S>>>,
    ) -> Self {
        self._fields.17 = value.into();
        self
    }
    /// Set the `associatedMedia` field to an Option value (optional)
    pub fn maybe_associated_media(
        mut self,
        value: Option<RecipeAssociatedMedia<S>>,
    ) -> Self {
        self._fields.17 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `audience` field (optional)
    pub fn audience(mut self, value: impl Into<Option<RecipeAudience<S>>>) -> Self {
        self._fields.18 = value.into();
        self
    }
    /// Set the `audience` field to an Option value (optional)
    pub fn maybe_audience(mut self, value: Option<RecipeAudience<S>>) -> Self {
        self._fields.18 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `audio` field (optional)
    pub fn audio(mut self, value: impl Into<Option<RecipeAudio<S>>>) -> Self {
        self._fields.19 = value.into();
        self
    }
    /// Set the `audio` field to an Option value (optional)
    pub fn maybe_audio(mut self, value: Option<RecipeAudio<S>>) -> Self {
        self._fields.19 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `author` field (optional)
    pub fn author(mut self, value: impl Into<Option<RecipeAuthor<S>>>) -> Self {
        self._fields.20 = value.into();
        self
    }
    /// Set the `author` field to an Option value (optional)
    pub fn maybe_author(mut self, value: Option<RecipeAuthor<S>>) -> Self {
        self._fields.20 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `award` field (optional)
    pub fn award(mut self, value: impl Into<Option<RecipeAward<S>>>) -> Self {
        self._fields.21 = value.into();
        self
    }
    /// Set the `award` field to an Option value (optional)
    pub fn maybe_award(mut self, value: Option<RecipeAward<S>>) -> Self {
        self._fields.21 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `awards` field (optional)
    pub fn awards(mut self, value: impl Into<Option<RecipeAwards<S>>>) -> Self {
        self._fields.22 = value.into();
        self
    }
    /// Set the `awards` field to an Option value (optional)
    pub fn maybe_awards(mut self, value: Option<RecipeAwards<S>>) -> Self {
        self._fields.22 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `character` field (optional)
    pub fn character(mut self, value: impl Into<Option<RecipeCharacter<S>>>) -> Self {
        self._fields.23 = value.into();
        self
    }
    /// Set the `character` field to an Option value (optional)
    pub fn maybe_character(mut self, value: Option<RecipeCharacter<S>>) -> Self {
        self._fields.23 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `citation` field (optional)
    pub fn citation(mut self, value: impl Into<Option<RecipeCitation<S>>>) -> Self {
        self._fields.24 = value.into();
        self
    }
    /// Set the `citation` field to an Option value (optional)
    pub fn maybe_citation(mut self, value: Option<RecipeCitation<S>>) -> Self {
        self._fields.24 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `comment` field (optional)
    pub fn comment(mut self, value: impl Into<Option<RecipeComment<S>>>) -> Self {
        self._fields.25 = value.into();
        self
    }
    /// Set the `comment` field to an Option value (optional)
    pub fn maybe_comment(mut self, value: Option<RecipeComment<S>>) -> Self {
        self._fields.25 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `commentCount` field (optional)
    pub fn comment_count(
        mut self,
        value: impl Into<Option<RecipeCommentCount<S>>>,
    ) -> Self {
        self._fields.26 = value.into();
        self
    }
    /// Set the `commentCount` field to an Option value (optional)
    pub fn maybe_comment_count(mut self, value: Option<RecipeCommentCount<S>>) -> Self {
        self._fields.26 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `conditionsOfAccess` field (optional)
    pub fn conditions_of_access(
        mut self,
        value: impl Into<Option<RecipeConditionsOfAccess<S>>>,
    ) -> Self {
        self._fields.27 = value.into();
        self
    }
    /// Set the `conditionsOfAccess` field to an Option value (optional)
    pub fn maybe_conditions_of_access(
        mut self,
        value: Option<RecipeConditionsOfAccess<S>>,
    ) -> Self {
        self._fields.27 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `contentLocation` field (optional)
    pub fn content_location(
        mut self,
        value: impl Into<Option<RecipeContentLocation<S>>>,
    ) -> Self {
        self._fields.28 = value.into();
        self
    }
    /// Set the `contentLocation` field to an Option value (optional)
    pub fn maybe_content_location(
        mut self,
        value: Option<RecipeContentLocation<S>>,
    ) -> Self {
        self._fields.28 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `contentRating` field (optional)
    pub fn content_rating(
        mut self,
        value: impl Into<Option<RecipeContentRating<S>>>,
    ) -> Self {
        self._fields.29 = value.into();
        self
    }
    /// Set the `contentRating` field to an Option value (optional)
    pub fn maybe_content_rating(
        mut self,
        value: Option<RecipeContentRating<S>>,
    ) -> Self {
        self._fields.29 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `contentReferenceTime` field (optional)
    pub fn content_reference_time(
        mut self,
        value: impl Into<Option<RecipeContentReferenceTime<S>>>,
    ) -> Self {
        self._fields.30 = value.into();
        self
    }
    /// Set the `contentReferenceTime` field to an Option value (optional)
    pub fn maybe_content_reference_time(
        mut self,
        value: Option<RecipeContentReferenceTime<S>>,
    ) -> Self {
        self._fields.30 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `contributor` field (optional)
    pub fn contributor(
        mut self,
        value: impl Into<Option<RecipeContributor<S>>>,
    ) -> Self {
        self._fields.31 = value.into();
        self
    }
    /// Set the `contributor` field to an Option value (optional)
    pub fn maybe_contributor(mut self, value: Option<RecipeContributor<S>>) -> Self {
        self._fields.31 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `cookTime` field (optional)
    pub fn cook_time(mut self, value: impl Into<Option<RecipeCookTime<S>>>) -> Self {
        self._fields.32 = value.into();
        self
    }
    /// Set the `cookTime` field to an Option value (optional)
    pub fn maybe_cook_time(mut self, value: Option<RecipeCookTime<S>>) -> Self {
        self._fields.32 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `cookingMethod` field (optional)
    pub fn cooking_method(
        mut self,
        value: impl Into<Option<RecipeCookingMethod<S>>>,
    ) -> Self {
        self._fields.33 = value.into();
        self
    }
    /// Set the `cookingMethod` field to an Option value (optional)
    pub fn maybe_cooking_method(
        mut self,
        value: Option<RecipeCookingMethod<S>>,
    ) -> Self {
        self._fields.33 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `copyrightHolder` field (optional)
    pub fn copyright_holder(
        mut self,
        value: impl Into<Option<RecipeCopyrightHolder<S>>>,
    ) -> Self {
        self._fields.34 = value.into();
        self
    }
    /// Set the `copyrightHolder` field to an Option value (optional)
    pub fn maybe_copyright_holder(
        mut self,
        value: Option<RecipeCopyrightHolder<S>>,
    ) -> Self {
        self._fields.34 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `copyrightNotice` field (optional)
    pub fn copyright_notice(
        mut self,
        value: impl Into<Option<RecipeCopyrightNotice<S>>>,
    ) -> Self {
        self._fields.35 = value.into();
        self
    }
    /// Set the `copyrightNotice` field to an Option value (optional)
    pub fn maybe_copyright_notice(
        mut self,
        value: Option<RecipeCopyrightNotice<S>>,
    ) -> Self {
        self._fields.35 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `copyrightYear` field (optional)
    pub fn copyright_year(
        mut self,
        value: impl Into<Option<RecipeCopyrightYear<S>>>,
    ) -> Self {
        self._fields.36 = value.into();
        self
    }
    /// Set the `copyrightYear` field to an Option value (optional)
    pub fn maybe_copyright_year(
        mut self,
        value: Option<RecipeCopyrightYear<S>>,
    ) -> Self {
        self._fields.36 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `correction` field (optional)
    pub fn correction(mut self, value: impl Into<Option<RecipeCorrection<S>>>) -> Self {
        self._fields.37 = value.into();
        self
    }
    /// Set the `correction` field to an Option value (optional)
    pub fn maybe_correction(mut self, value: Option<RecipeCorrection<S>>) -> Self {
        self._fields.37 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `countryOfOrigin` field (optional)
    pub fn country_of_origin(
        mut self,
        value: impl Into<Option<RecipeCountryOfOrigin<S>>>,
    ) -> Self {
        self._fields.38 = value.into();
        self
    }
    /// Set the `countryOfOrigin` field to an Option value (optional)
    pub fn maybe_country_of_origin(
        mut self,
        value: Option<RecipeCountryOfOrigin<S>>,
    ) -> Self {
        self._fields.38 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `creativeWorkStatus` field (optional)
    pub fn creative_work_status(
        mut self,
        value: impl Into<Option<RecipeCreativeWorkStatus<S>>>,
    ) -> Self {
        self._fields.39 = value.into();
        self
    }
    /// Set the `creativeWorkStatus` field to an Option value (optional)
    pub fn maybe_creative_work_status(
        mut self,
        value: Option<RecipeCreativeWorkStatus<S>>,
    ) -> Self {
        self._fields.39 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `creator` field (optional)
    pub fn creator(mut self, value: impl Into<Option<RecipeCreator<S>>>) -> Self {
        self._fields.40 = value.into();
        self
    }
    /// Set the `creator` field to an Option value (optional)
    pub fn maybe_creator(mut self, value: Option<RecipeCreator<S>>) -> Self {
        self._fields.40 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `creditText` field (optional)
    pub fn credit_text(mut self, value: impl Into<Option<RecipeCreditText<S>>>) -> Self {
        self._fields.41 = value.into();
        self
    }
    /// Set the `creditText` field to an Option value (optional)
    pub fn maybe_credit_text(mut self, value: Option<RecipeCreditText<S>>) -> Self {
        self._fields.41 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `dateCreated` field (optional)
    pub fn date_created(
        mut self,
        value: impl Into<Option<RecipeDateCreated<S>>>,
    ) -> Self {
        self._fields.42 = value.into();
        self
    }
    /// Set the `dateCreated` field to an Option value (optional)
    pub fn maybe_date_created(mut self, value: Option<RecipeDateCreated<S>>) -> Self {
        self._fields.42 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `dateModified` field (optional)
    pub fn date_modified(
        mut self,
        value: impl Into<Option<RecipeDateModified<S>>>,
    ) -> Self {
        self._fields.43 = value.into();
        self
    }
    /// Set the `dateModified` field to an Option value (optional)
    pub fn maybe_date_modified(mut self, value: Option<RecipeDateModified<S>>) -> Self {
        self._fields.43 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `datePublished` field (optional)
    pub fn date_published(
        mut self,
        value: impl Into<Option<RecipeDatePublished<S>>>,
    ) -> Self {
        self._fields.44 = value.into();
        self
    }
    /// Set the `datePublished` field to an Option value (optional)
    pub fn maybe_date_published(
        mut self,
        value: Option<RecipeDatePublished<S>>,
    ) -> Self {
        self._fields.44 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `description` field (optional)
    pub fn description(
        mut self,
        value: impl Into<Option<RecipeDescription<S>>>,
    ) -> Self {
        self._fields.45 = value.into();
        self
    }
    /// Set the `description` field to an Option value (optional)
    pub fn maybe_description(mut self, value: Option<RecipeDescription<S>>) -> Self {
        self._fields.45 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `digitalSourceType` field (optional)
    pub fn digital_source_type(
        mut self,
        value: impl Into<Option<RecipeDigitalSourceType<S>>>,
    ) -> Self {
        self._fields.46 = value.into();
        self
    }
    /// Set the `digitalSourceType` field to an Option value (optional)
    pub fn maybe_digital_source_type(
        mut self,
        value: Option<RecipeDigitalSourceType<S>>,
    ) -> Self {
        self._fields.46 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `disambiguatingDescription` field (optional)
    pub fn disambiguating_description(
        mut self,
        value: impl Into<Option<RecipeDisambiguatingDescription<S>>>,
    ) -> Self {
        self._fields.47 = value.into();
        self
    }
    /// Set the `disambiguatingDescription` field to an Option value (optional)
    pub fn maybe_disambiguating_description(
        mut self,
        value: Option<RecipeDisambiguatingDescription<S>>,
    ) -> Self {
        self._fields.47 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `discussionUrl` field (optional)
    pub fn discussion_url(
        mut self,
        value: impl Into<Option<RecipeDiscussionUrl<S>>>,
    ) -> Self {
        self._fields.48 = value.into();
        self
    }
    /// Set the `discussionUrl` field to an Option value (optional)
    pub fn maybe_discussion_url(
        mut self,
        value: Option<RecipeDiscussionUrl<S>>,
    ) -> Self {
        self._fields.48 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `editEIDR` field (optional)
    pub fn edit_eidr(mut self, value: impl Into<Option<RecipeEditEidr<S>>>) -> Self {
        self._fields.49 = value.into();
        self
    }
    /// Set the `editEIDR` field to an Option value (optional)
    pub fn maybe_edit_eidr(mut self, value: Option<RecipeEditEidr<S>>) -> Self {
        self._fields.49 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `editor` field (optional)
    pub fn editor(mut self, value: impl Into<Option<RecipeEditor<S>>>) -> Self {
        self._fields.50 = value.into();
        self
    }
    /// Set the `editor` field to an Option value (optional)
    pub fn maybe_editor(mut self, value: Option<RecipeEditor<S>>) -> Self {
        self._fields.50 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `educationalAlignment` field (optional)
    pub fn educational_alignment(
        mut self,
        value: impl Into<Option<RecipeEducationalAlignment<S>>>,
    ) -> Self {
        self._fields.51 = value.into();
        self
    }
    /// Set the `educationalAlignment` field to an Option value (optional)
    pub fn maybe_educational_alignment(
        mut self,
        value: Option<RecipeEducationalAlignment<S>>,
    ) -> Self {
        self._fields.51 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `educationalLevel` field (optional)
    pub fn educational_level(
        mut self,
        value: impl Into<Option<RecipeEducationalLevel<S>>>,
    ) -> Self {
        self._fields.52 = value.into();
        self
    }
    /// Set the `educationalLevel` field to an Option value (optional)
    pub fn maybe_educational_level(
        mut self,
        value: Option<RecipeEducationalLevel<S>>,
    ) -> Self {
        self._fields.52 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `educationalUse` field (optional)
    pub fn educational_use(
        mut self,
        value: impl Into<Option<RecipeEducationalUse<S>>>,
    ) -> Self {
        self._fields.53 = value.into();
        self
    }
    /// Set the `educationalUse` field to an Option value (optional)
    pub fn maybe_educational_use(
        mut self,
        value: Option<RecipeEducationalUse<S>>,
    ) -> Self {
        self._fields.53 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `encoding` field (optional)
    pub fn encoding(mut self, value: impl Into<Option<RecipeEncoding<S>>>) -> Self {
        self._fields.54 = value.into();
        self
    }
    /// Set the `encoding` field to an Option value (optional)
    pub fn maybe_encoding(mut self, value: Option<RecipeEncoding<S>>) -> Self {
        self._fields.54 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `encodingFormat` field (optional)
    pub fn encoding_format(
        mut self,
        value: impl Into<Option<RecipeEncodingFormat<S>>>,
    ) -> Self {
        self._fields.55 = value.into();
        self
    }
    /// Set the `encodingFormat` field to an Option value (optional)
    pub fn maybe_encoding_format(
        mut self,
        value: Option<RecipeEncodingFormat<S>>,
    ) -> Self {
        self._fields.55 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `encodings` field (optional)
    pub fn encodings(mut self, value: impl Into<Option<RecipeEncodings<S>>>) -> Self {
        self._fields.56 = value.into();
        self
    }
    /// Set the `encodings` field to an Option value (optional)
    pub fn maybe_encodings(mut self, value: Option<RecipeEncodings<S>>) -> Self {
        self._fields.56 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `estimatedCost` field (optional)
    pub fn estimated_cost(
        mut self,
        value: impl Into<Option<RecipeEstimatedCost<S>>>,
    ) -> Self {
        self._fields.57 = value.into();
        self
    }
    /// Set the `estimatedCost` field to an Option value (optional)
    pub fn maybe_estimated_cost(
        mut self,
        value: Option<RecipeEstimatedCost<S>>,
    ) -> Self {
        self._fields.57 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `exampleOfWork` field (optional)
    pub fn example_of_work(
        mut self,
        value: impl Into<Option<RecipeExampleOfWork<S>>>,
    ) -> Self {
        self._fields.58 = value.into();
        self
    }
    /// Set the `exampleOfWork` field to an Option value (optional)
    pub fn maybe_example_of_work(
        mut self,
        value: Option<RecipeExampleOfWork<S>>,
    ) -> Self {
        self._fields.58 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `expires` field (optional)
    pub fn expires(mut self, value: impl Into<Option<RecipeExpires<S>>>) -> Self {
        self._fields.59 = value.into();
        self
    }
    /// Set the `expires` field to an Option value (optional)
    pub fn maybe_expires(mut self, value: Option<RecipeExpires<S>>) -> Self {
        self._fields.59 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `fileFormat` field (optional)
    pub fn file_format(mut self, value: impl Into<Option<RecipeFileFormat<S>>>) -> Self {
        self._fields.60 = value.into();
        self
    }
    /// Set the `fileFormat` field to an Option value (optional)
    pub fn maybe_file_format(mut self, value: Option<RecipeFileFormat<S>>) -> Self {
        self._fields.60 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `funder` field (optional)
    pub fn funder(mut self, value: impl Into<Option<RecipeFunder<S>>>) -> Self {
        self._fields.61 = value.into();
        self
    }
    /// Set the `funder` field to an Option value (optional)
    pub fn maybe_funder(mut self, value: Option<RecipeFunder<S>>) -> Self {
        self._fields.61 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `funding` field (optional)
    pub fn funding(mut self, value: impl Into<Option<RecipeFunding<S>>>) -> Self {
        self._fields.62 = value.into();
        self
    }
    /// Set the `funding` field to an Option value (optional)
    pub fn maybe_funding(mut self, value: Option<RecipeFunding<S>>) -> Self {
        self._fields.62 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `genre` field (optional)
    pub fn genre(mut self, value: impl Into<Option<RecipeGenre<S>>>) -> Self {
        self._fields.63 = value.into();
        self
    }
    /// Set the `genre` field to an Option value (optional)
    pub fn maybe_genre(mut self, value: Option<RecipeGenre<S>>) -> Self {
        self._fields.63 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `hasPart` field (optional)
    pub fn has_part(mut self, value: impl Into<Option<RecipeHasPart<S>>>) -> Self {
        self._fields.64 = value.into();
        self
    }
    /// Set the `hasPart` field to an Option value (optional)
    pub fn maybe_has_part(mut self, value: Option<RecipeHasPart<S>>) -> Self {
        self._fields.64 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `headline` field (optional)
    pub fn headline(mut self, value: impl Into<Option<RecipeHeadline<S>>>) -> Self {
        self._fields.65 = value.into();
        self
    }
    /// Set the `headline` field to an Option value (optional)
    pub fn maybe_headline(mut self, value: Option<RecipeHeadline<S>>) -> Self {
        self._fields.65 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `identifier` field (optional)
    pub fn identifier(mut self, value: impl Into<Option<RecipeIdentifier<S>>>) -> Self {
        self._fields.66 = value.into();
        self
    }
    /// Set the `identifier` field to an Option value (optional)
    pub fn maybe_identifier(mut self, value: Option<RecipeIdentifier<S>>) -> Self {
        self._fields.66 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `image` field (optional)
    pub fn image(mut self, value: impl Into<Option<RecipeImage<S>>>) -> Self {
        self._fields.67 = value.into();
        self
    }
    /// Set the `image` field to an Option value (optional)
    pub fn maybe_image(mut self, value: Option<RecipeImage<S>>) -> Self {
        self._fields.67 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `inLanguage` field (optional)
    pub fn in_language(mut self, value: impl Into<Option<RecipeInLanguage<S>>>) -> Self {
        self._fields.68 = value.into();
        self
    }
    /// Set the `inLanguage` field to an Option value (optional)
    pub fn maybe_in_language(mut self, value: Option<RecipeInLanguage<S>>) -> Self {
        self._fields.68 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `ingredients` field (optional)
    pub fn ingredients(
        mut self,
        value: impl Into<Option<RecipeIngredients<S>>>,
    ) -> Self {
        self._fields.69 = value.into();
        self
    }
    /// Set the `ingredients` field to an Option value (optional)
    pub fn maybe_ingredients(mut self, value: Option<RecipeIngredients<S>>) -> Self {
        self._fields.69 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `interactionStatistic` field (optional)
    pub fn interaction_statistic(
        mut self,
        value: impl Into<Option<RecipeInteractionStatistic<S>>>,
    ) -> Self {
        self._fields.70 = value.into();
        self
    }
    /// Set the `interactionStatistic` field to an Option value (optional)
    pub fn maybe_interaction_statistic(
        mut self,
        value: Option<RecipeInteractionStatistic<S>>,
    ) -> Self {
        self._fields.70 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `interactivityType` field (optional)
    pub fn interactivity_type(
        mut self,
        value: impl Into<Option<RecipeInteractivityType<S>>>,
    ) -> Self {
        self._fields.71 = value.into();
        self
    }
    /// Set the `interactivityType` field to an Option value (optional)
    pub fn maybe_interactivity_type(
        mut self,
        value: Option<RecipeInteractivityType<S>>,
    ) -> Self {
        self._fields.71 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `interpretedAsClaim` field (optional)
    pub fn interpreted_as_claim(
        mut self,
        value: impl Into<Option<RecipeInterpretedAsClaim<S>>>,
    ) -> Self {
        self._fields.72 = value.into();
        self
    }
    /// Set the `interpretedAsClaim` field to an Option value (optional)
    pub fn maybe_interpreted_as_claim(
        mut self,
        value: Option<RecipeInterpretedAsClaim<S>>,
    ) -> Self {
        self._fields.72 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `isAccessibleForFree` field (optional)
    pub fn is_accessible_for_free(
        mut self,
        value: impl Into<Option<RecipeIsAccessibleForFree<S>>>,
    ) -> Self {
        self._fields.73 = value.into();
        self
    }
    /// Set the `isAccessibleForFree` field to an Option value (optional)
    pub fn maybe_is_accessible_for_free(
        mut self,
        value: Option<RecipeIsAccessibleForFree<S>>,
    ) -> Self {
        self._fields.73 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `isBasedOn` field (optional)
    pub fn is_based_on(mut self, value: impl Into<Option<RecipeIsBasedOn<S>>>) -> Self {
        self._fields.74 = value.into();
        self
    }
    /// Set the `isBasedOn` field to an Option value (optional)
    pub fn maybe_is_based_on(mut self, value: Option<RecipeIsBasedOn<S>>) -> Self {
        self._fields.74 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `isBasedOnUrl` field (optional)
    pub fn is_based_on_url(
        mut self,
        value: impl Into<Option<RecipeIsBasedOnUrl<S>>>,
    ) -> Self {
        self._fields.75 = value.into();
        self
    }
    /// Set the `isBasedOnUrl` field to an Option value (optional)
    pub fn maybe_is_based_on_url(
        mut self,
        value: Option<RecipeIsBasedOnUrl<S>>,
    ) -> Self {
        self._fields.75 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `isFamilyFriendly` field (optional)
    pub fn is_family_friendly(
        mut self,
        value: impl Into<Option<RecipeIsFamilyFriendly<S>>>,
    ) -> Self {
        self._fields.76 = value.into();
        self
    }
    /// Set the `isFamilyFriendly` field to an Option value (optional)
    pub fn maybe_is_family_friendly(
        mut self,
        value: Option<RecipeIsFamilyFriendly<S>>,
    ) -> Self {
        self._fields.76 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `isPartOf` field (optional)
    pub fn is_part_of(mut self, value: impl Into<Option<RecipeIsPartOf<S>>>) -> Self {
        self._fields.77 = value.into();
        self
    }
    /// Set the `isPartOf` field to an Option value (optional)
    pub fn maybe_is_part_of(mut self, value: Option<RecipeIsPartOf<S>>) -> Self {
        self._fields.77 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `keywords` field (optional)
    pub fn keywords(mut self, value: impl Into<Option<RecipeKeywords<S>>>) -> Self {
        self._fields.78 = value.into();
        self
    }
    /// Set the `keywords` field to an Option value (optional)
    pub fn maybe_keywords(mut self, value: Option<RecipeKeywords<S>>) -> Self {
        self._fields.78 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `learningResourceType` field (optional)
    pub fn learning_resource_type(
        mut self,
        value: impl Into<Option<RecipeLearningResourceType<S>>>,
    ) -> Self {
        self._fields.79 = value.into();
        self
    }
    /// Set the `learningResourceType` field to an Option value (optional)
    pub fn maybe_learning_resource_type(
        mut self,
        value: Option<RecipeLearningResourceType<S>>,
    ) -> Self {
        self._fields.79 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `license` field (optional)
    pub fn license(mut self, value: impl Into<Option<RecipeLicense<S>>>) -> Self {
        self._fields.80 = value.into();
        self
    }
    /// Set the `license` field to an Option value (optional)
    pub fn maybe_license(mut self, value: Option<RecipeLicense<S>>) -> Self {
        self._fields.80 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `locationCreated` field (optional)
    pub fn location_created(
        mut self,
        value: impl Into<Option<RecipeLocationCreated<S>>>,
    ) -> Self {
        self._fields.81 = value.into();
        self
    }
    /// Set the `locationCreated` field to an Option value (optional)
    pub fn maybe_location_created(
        mut self,
        value: Option<RecipeLocationCreated<S>>,
    ) -> Self {
        self._fields.81 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `mainEntity` field (optional)
    pub fn main_entity(mut self, value: impl Into<Option<RecipeMainEntity<S>>>) -> Self {
        self._fields.82 = value.into();
        self
    }
    /// Set the `mainEntity` field to an Option value (optional)
    pub fn maybe_main_entity(mut self, value: Option<RecipeMainEntity<S>>) -> Self {
        self._fields.82 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `mainEntityOfPage` field (optional)
    pub fn main_entity_of_page(
        mut self,
        value: impl Into<Option<RecipeMainEntityOfPage<S>>>,
    ) -> Self {
        self._fields.83 = value.into();
        self
    }
    /// Set the `mainEntityOfPage` field to an Option value (optional)
    pub fn maybe_main_entity_of_page(
        mut self,
        value: Option<RecipeMainEntityOfPage<S>>,
    ) -> Self {
        self._fields.83 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `maintainer` field (optional)
    pub fn maintainer(mut self, value: impl Into<Option<RecipeMaintainer<S>>>) -> Self {
        self._fields.84 = value.into();
        self
    }
    /// Set the `maintainer` field to an Option value (optional)
    pub fn maybe_maintainer(mut self, value: Option<RecipeMaintainer<S>>) -> Self {
        self._fields.84 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `material` field (optional)
    pub fn material(mut self, value: impl Into<Option<RecipeMaterial<S>>>) -> Self {
        self._fields.85 = value.into();
        self
    }
    /// Set the `material` field to an Option value (optional)
    pub fn maybe_material(mut self, value: Option<RecipeMaterial<S>>) -> Self {
        self._fields.85 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `materialExtent` field (optional)
    pub fn material_extent(
        mut self,
        value: impl Into<Option<RecipeMaterialExtent<S>>>,
    ) -> Self {
        self._fields.86 = value.into();
        self
    }
    /// Set the `materialExtent` field to an Option value (optional)
    pub fn maybe_material_extent(
        mut self,
        value: Option<RecipeMaterialExtent<S>>,
    ) -> Self {
        self._fields.86 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `mentions` field (optional)
    pub fn mentions(mut self, value: impl Into<Option<RecipeMentions<S>>>) -> Self {
        self._fields.87 = value.into();
        self
    }
    /// Set the `mentions` field to an Option value (optional)
    pub fn maybe_mentions(mut self, value: Option<RecipeMentions<S>>) -> Self {
        self._fields.87 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `name` field (optional)
    pub fn name(mut self, value: impl Into<Option<RecipeName<S>>>) -> Self {
        self._fields.88 = value.into();
        self
    }
    /// Set the `name` field to an Option value (optional)
    pub fn maybe_name(mut self, value: Option<RecipeName<S>>) -> Self {
        self._fields.88 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `nutrition` field (optional)
    pub fn nutrition(mut self, value: impl Into<Option<RecipeNutrition<S>>>) -> Self {
        self._fields.89 = value.into();
        self
    }
    /// Set the `nutrition` field to an Option value (optional)
    pub fn maybe_nutrition(mut self, value: Option<RecipeNutrition<S>>) -> Self {
        self._fields.89 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `offers` field (optional)
    pub fn offers(mut self, value: impl Into<Option<RecipeOffers<S>>>) -> Self {
        self._fields.90 = value.into();
        self
    }
    /// Set the `offers` field to an Option value (optional)
    pub fn maybe_offers(mut self, value: Option<RecipeOffers<S>>) -> Self {
        self._fields.90 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `pattern` field (optional)
    pub fn pattern(mut self, value: impl Into<Option<RecipePattern<S>>>) -> Self {
        self._fields.91 = value.into();
        self
    }
    /// Set the `pattern` field to an Option value (optional)
    pub fn maybe_pattern(mut self, value: Option<RecipePattern<S>>) -> Self {
        self._fields.91 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `performTime` field (optional)
    pub fn perform_time(
        mut self,
        value: impl Into<Option<RecipePerformTime<S>>>,
    ) -> Self {
        self._fields.92 = value.into();
        self
    }
    /// Set the `performTime` field to an Option value (optional)
    pub fn maybe_perform_time(mut self, value: Option<RecipePerformTime<S>>) -> Self {
        self._fields.92 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `position` field (optional)
    pub fn position(mut self, value: impl Into<Option<RecipePosition<S>>>) -> Self {
        self._fields.93 = value.into();
        self
    }
    /// Set the `position` field to an Option value (optional)
    pub fn maybe_position(mut self, value: Option<RecipePosition<S>>) -> Self {
        self._fields.93 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `potentialAction` field (optional)
    pub fn potential_action(
        mut self,
        value: impl Into<Option<RecipePotentialAction<S>>>,
    ) -> Self {
        self._fields.94 = value.into();
        self
    }
    /// Set the `potentialAction` field to an Option value (optional)
    pub fn maybe_potential_action(
        mut self,
        value: Option<RecipePotentialAction<S>>,
    ) -> Self {
        self._fields.94 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `prepTime` field (optional)
    pub fn prep_time(mut self, value: impl Into<Option<RecipePrepTime<S>>>) -> Self {
        self._fields.95 = value.into();
        self
    }
    /// Set the `prepTime` field to an Option value (optional)
    pub fn maybe_prep_time(mut self, value: Option<RecipePrepTime<S>>) -> Self {
        self._fields.95 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `producer` field (optional)
    pub fn producer(mut self, value: impl Into<Option<RecipeProducer<S>>>) -> Self {
        self._fields.96 = value.into();
        self
    }
    /// Set the `producer` field to an Option value (optional)
    pub fn maybe_producer(mut self, value: Option<RecipeProducer<S>>) -> Self {
        self._fields.96 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `provider` field (optional)
    pub fn provider(mut self, value: impl Into<Option<RecipeProvider<S>>>) -> Self {
        self._fields.97 = value.into();
        self
    }
    /// Set the `provider` field to an Option value (optional)
    pub fn maybe_provider(mut self, value: Option<RecipeProvider<S>>) -> Self {
        self._fields.97 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `publication` field (optional)
    pub fn publication(
        mut self,
        value: impl Into<Option<RecipePublication<S>>>,
    ) -> Self {
        self._fields.98 = value.into();
        self
    }
    /// Set the `publication` field to an Option value (optional)
    pub fn maybe_publication(mut self, value: Option<RecipePublication<S>>) -> Self {
        self._fields.98 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `publisher` field (optional)
    pub fn publisher(mut self, value: impl Into<Option<RecipePublisher<S>>>) -> Self {
        self._fields.99 = value.into();
        self
    }
    /// Set the `publisher` field to an Option value (optional)
    pub fn maybe_publisher(mut self, value: Option<RecipePublisher<S>>) -> Self {
        self._fields.99 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `publisherImprint` field (optional)
    pub fn publisher_imprint(
        mut self,
        value: impl Into<Option<RecipePublisherImprint<S>>>,
    ) -> Self {
        self._fields.100 = value.into();
        self
    }
    /// Set the `publisherImprint` field to an Option value (optional)
    pub fn maybe_publisher_imprint(
        mut self,
        value: Option<RecipePublisherImprint<S>>,
    ) -> Self {
        self._fields.100 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `publishingPrinciples` field (optional)
    pub fn publishing_principles(
        mut self,
        value: impl Into<Option<RecipePublishingPrinciples<S>>>,
    ) -> Self {
        self._fields.101 = value.into();
        self
    }
    /// Set the `publishingPrinciples` field to an Option value (optional)
    pub fn maybe_publishing_principles(
        mut self,
        value: Option<RecipePublishingPrinciples<S>>,
    ) -> Self {
        self._fields.101 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `recipeCategory` field (optional)
    pub fn recipe_category(
        mut self,
        value: impl Into<Option<RecipeRecipeCategory<S>>>,
    ) -> Self {
        self._fields.102 = value.into();
        self
    }
    /// Set the `recipeCategory` field to an Option value (optional)
    pub fn maybe_recipe_category(
        mut self,
        value: Option<RecipeRecipeCategory<S>>,
    ) -> Self {
        self._fields.102 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `recipeCuisine` field (optional)
    pub fn recipe_cuisine(
        mut self,
        value: impl Into<Option<RecipeRecipeCuisine<S>>>,
    ) -> Self {
        self._fields.103 = value.into();
        self
    }
    /// Set the `recipeCuisine` field to an Option value (optional)
    pub fn maybe_recipe_cuisine(
        mut self,
        value: Option<RecipeRecipeCuisine<S>>,
    ) -> Self {
        self._fields.103 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `recipeIngredient` field (optional)
    pub fn recipe_ingredient(
        mut self,
        value: impl Into<Option<RecipeRecipeIngredient<S>>>,
    ) -> Self {
        self._fields.104 = value.into();
        self
    }
    /// Set the `recipeIngredient` field to an Option value (optional)
    pub fn maybe_recipe_ingredient(
        mut self,
        value: Option<RecipeRecipeIngredient<S>>,
    ) -> Self {
        self._fields.104 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `recipeInstructions` field (optional)
    pub fn recipe_instructions(
        mut self,
        value: impl Into<Option<RecipeRecipeInstructions<S>>>,
    ) -> Self {
        self._fields.105 = value.into();
        self
    }
    /// Set the `recipeInstructions` field to an Option value (optional)
    pub fn maybe_recipe_instructions(
        mut self,
        value: Option<RecipeRecipeInstructions<S>>,
    ) -> Self {
        self._fields.105 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `recipeYield` field (optional)
    pub fn recipe_yield(
        mut self,
        value: impl Into<Option<RecipeRecipeYield<S>>>,
    ) -> Self {
        self._fields.106 = value.into();
        self
    }
    /// Set the `recipeYield` field to an Option value (optional)
    pub fn maybe_recipe_yield(mut self, value: Option<RecipeRecipeYield<S>>) -> Self {
        self._fields.106 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `recordedAt` field (optional)
    pub fn recorded_at(mut self, value: impl Into<Option<RecipeRecordedAt<S>>>) -> Self {
        self._fields.107 = value.into();
        self
    }
    /// Set the `recordedAt` field to an Option value (optional)
    pub fn maybe_recorded_at(mut self, value: Option<RecipeRecordedAt<S>>) -> Self {
        self._fields.107 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `releasedEvent` field (optional)
    pub fn released_event(
        mut self,
        value: impl Into<Option<RecipeReleasedEvent<S>>>,
    ) -> Self {
        self._fields.108 = value.into();
        self
    }
    /// Set the `releasedEvent` field to an Option value (optional)
    pub fn maybe_released_event(
        mut self,
        value: Option<RecipeReleasedEvent<S>>,
    ) -> Self {
        self._fields.108 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `review` field (optional)
    pub fn review(mut self, value: impl Into<Option<RecipeReview<S>>>) -> Self {
        self._fields.109 = value.into();
        self
    }
    /// Set the `review` field to an Option value (optional)
    pub fn maybe_review(mut self, value: Option<RecipeReview<S>>) -> Self {
        self._fields.109 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `reviews` field (optional)
    pub fn reviews(mut self, value: impl Into<Option<RecipeReviews<S>>>) -> Self {
        self._fields.110 = value.into();
        self
    }
    /// Set the `reviews` field to an Option value (optional)
    pub fn maybe_reviews(mut self, value: Option<RecipeReviews<S>>) -> Self {
        self._fields.110 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `sameAs` field (optional)
    pub fn same_as(mut self, value: impl Into<Option<RecipeSameAs<S>>>) -> Self {
        self._fields.111 = value.into();
        self
    }
    /// Set the `sameAs` field to an Option value (optional)
    pub fn maybe_same_as(mut self, value: Option<RecipeSameAs<S>>) -> Self {
        self._fields.111 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `schemaVersion` field (optional)
    pub fn schema_version(
        mut self,
        value: impl Into<Option<RecipeSchemaVersion<S>>>,
    ) -> Self {
        self._fields.112 = value.into();
        self
    }
    /// Set the `schemaVersion` field to an Option value (optional)
    pub fn maybe_schema_version(
        mut self,
        value: Option<RecipeSchemaVersion<S>>,
    ) -> Self {
        self._fields.112 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `sdDatePublished` field (optional)
    pub fn sd_date_published(
        mut self,
        value: impl Into<Option<RecipeSdDatePublished<S>>>,
    ) -> Self {
        self._fields.113 = value.into();
        self
    }
    /// Set the `sdDatePublished` field to an Option value (optional)
    pub fn maybe_sd_date_published(
        mut self,
        value: Option<RecipeSdDatePublished<S>>,
    ) -> Self {
        self._fields.113 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `sdLicense` field (optional)
    pub fn sd_license(mut self, value: impl Into<Option<RecipeSdLicense<S>>>) -> Self {
        self._fields.114 = value.into();
        self
    }
    /// Set the `sdLicense` field to an Option value (optional)
    pub fn maybe_sd_license(mut self, value: Option<RecipeSdLicense<S>>) -> Self {
        self._fields.114 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `sdPublisher` field (optional)
    pub fn sd_publisher(
        mut self,
        value: impl Into<Option<RecipeSdPublisher<S>>>,
    ) -> Self {
        self._fields.115 = value.into();
        self
    }
    /// Set the `sdPublisher` field to an Option value (optional)
    pub fn maybe_sd_publisher(mut self, value: Option<RecipeSdPublisher<S>>) -> Self {
        self._fields.115 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `size` field (optional)
    pub fn size(mut self, value: impl Into<Option<RecipeSize<S>>>) -> Self {
        self._fields.116 = value.into();
        self
    }
    /// Set the `size` field to an Option value (optional)
    pub fn maybe_size(mut self, value: Option<RecipeSize<S>>) -> Self {
        self._fields.116 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `sourceOrganization` field (optional)
    pub fn source_organization(
        mut self,
        value: impl Into<Option<RecipeSourceOrganization<S>>>,
    ) -> Self {
        self._fields.117 = value.into();
        self
    }
    /// Set the `sourceOrganization` field to an Option value (optional)
    pub fn maybe_source_organization(
        mut self,
        value: Option<RecipeSourceOrganization<S>>,
    ) -> Self {
        self._fields.117 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `spatial` field (optional)
    pub fn spatial(mut self, value: impl Into<Option<RecipeSpatial<S>>>) -> Self {
        self._fields.118 = value.into();
        self
    }
    /// Set the `spatial` field to an Option value (optional)
    pub fn maybe_spatial(mut self, value: Option<RecipeSpatial<S>>) -> Self {
        self._fields.118 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `spatialCoverage` field (optional)
    pub fn spatial_coverage(
        mut self,
        value: impl Into<Option<RecipeSpatialCoverage<S>>>,
    ) -> Self {
        self._fields.119 = value.into();
        self
    }
    /// Set the `spatialCoverage` field to an Option value (optional)
    pub fn maybe_spatial_coverage(
        mut self,
        value: Option<RecipeSpatialCoverage<S>>,
    ) -> Self {
        self._fields.119 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `sponsor` field (optional)
    pub fn sponsor(mut self, value: impl Into<Option<RecipeSponsor<S>>>) -> Self {
        self._fields.120 = value.into();
        self
    }
    /// Set the `sponsor` field to an Option value (optional)
    pub fn maybe_sponsor(mut self, value: Option<RecipeSponsor<S>>) -> Self {
        self._fields.120 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `step` field (optional)
    pub fn step(mut self, value: impl Into<Option<RecipeStep<S>>>) -> Self {
        self._fields.121 = value.into();
        self
    }
    /// Set the `step` field to an Option value (optional)
    pub fn maybe_step(mut self, value: Option<RecipeStep<S>>) -> Self {
        self._fields.121 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `steps` field (optional)
    pub fn steps(mut self, value: impl Into<Option<RecipeSteps<S>>>) -> Self {
        self._fields.122 = value.into();
        self
    }
    /// Set the `steps` field to an Option value (optional)
    pub fn maybe_steps(mut self, value: Option<RecipeSteps<S>>) -> Self {
        self._fields.122 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `subjectOf` field (optional)
    pub fn subject_of(mut self, value: impl Into<Option<RecipeSubjectOf<S>>>) -> Self {
        self._fields.123 = value.into();
        self
    }
    /// Set the `subjectOf` field to an Option value (optional)
    pub fn maybe_subject_of(mut self, value: Option<RecipeSubjectOf<S>>) -> Self {
        self._fields.123 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `suitableForDiet` field (optional)
    pub fn suitable_for_diet(
        mut self,
        value: impl Into<Option<RecipeSuitableForDiet<S>>>,
    ) -> Self {
        self._fields.124 = value.into();
        self
    }
    /// Set the `suitableForDiet` field to an Option value (optional)
    pub fn maybe_suitable_for_diet(
        mut self,
        value: Option<RecipeSuitableForDiet<S>>,
    ) -> Self {
        self._fields.124 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `supply` field (optional)
    pub fn supply(mut self, value: impl Into<Option<RecipeSupply<S>>>) -> Self {
        self._fields.125 = value.into();
        self
    }
    /// Set the `supply` field to an Option value (optional)
    pub fn maybe_supply(mut self, value: Option<RecipeSupply<S>>) -> Self {
        self._fields.125 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `teaches` field (optional)
    pub fn teaches(mut self, value: impl Into<Option<RecipeTeaches<S>>>) -> Self {
        self._fields.126 = value.into();
        self
    }
    /// Set the `teaches` field to an Option value (optional)
    pub fn maybe_teaches(mut self, value: Option<RecipeTeaches<S>>) -> Self {
        self._fields.126 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `temporal` field (optional)
    pub fn temporal(mut self, value: impl Into<Option<RecipeTemporal<S>>>) -> Self {
        self._fields.127 = value.into();
        self
    }
    /// Set the `temporal` field to an Option value (optional)
    pub fn maybe_temporal(mut self, value: Option<RecipeTemporal<S>>) -> Self {
        self._fields.127 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `temporalCoverage` field (optional)
    pub fn temporal_coverage(
        mut self,
        value: impl Into<Option<RecipeTemporalCoverage<S>>>,
    ) -> Self {
        self._fields.128 = value.into();
        self
    }
    /// Set the `temporalCoverage` field to an Option value (optional)
    pub fn maybe_temporal_coverage(
        mut self,
        value: Option<RecipeTemporalCoverage<S>>,
    ) -> Self {
        self._fields.128 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `text` field (optional)
    pub fn text(mut self, value: impl Into<Option<RecipeText<S>>>) -> Self {
        self._fields.129 = value.into();
        self
    }
    /// Set the `text` field to an Option value (optional)
    pub fn maybe_text(mut self, value: Option<RecipeText<S>>) -> Self {
        self._fields.129 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `thumbnail` field (optional)
    pub fn thumbnail(mut self, value: impl Into<Option<RecipeThumbnail<S>>>) -> Self {
        self._fields.130 = value.into();
        self
    }
    /// Set the `thumbnail` field to an Option value (optional)
    pub fn maybe_thumbnail(mut self, value: Option<RecipeThumbnail<S>>) -> Self {
        self._fields.130 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `thumbnailUrl` field (optional)
    pub fn thumbnail_url(
        mut self,
        value: impl Into<Option<RecipeThumbnailUrl<S>>>,
    ) -> Self {
        self._fields.131 = value.into();
        self
    }
    /// Set the `thumbnailUrl` field to an Option value (optional)
    pub fn maybe_thumbnail_url(mut self, value: Option<RecipeThumbnailUrl<S>>) -> Self {
        self._fields.131 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `timeRequired` field (optional)
    pub fn time_required(
        mut self,
        value: impl Into<Option<RecipeTimeRequired<S>>>,
    ) -> Self {
        self._fields.132 = value.into();
        self
    }
    /// Set the `timeRequired` field to an Option value (optional)
    pub fn maybe_time_required(mut self, value: Option<RecipeTimeRequired<S>>) -> Self {
        self._fields.132 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `tool` field (optional)
    pub fn tool(mut self, value: impl Into<Option<RecipeTool<S>>>) -> Self {
        self._fields.133 = value.into();
        self
    }
    /// Set the `tool` field to an Option value (optional)
    pub fn maybe_tool(mut self, value: Option<RecipeTool<S>>) -> Self {
        self._fields.133 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `totalTime` field (optional)
    pub fn total_time(mut self, value: impl Into<Option<RecipeTotalTime<S>>>) -> Self {
        self._fields.134 = value.into();
        self
    }
    /// Set the `totalTime` field to an Option value (optional)
    pub fn maybe_total_time(mut self, value: Option<RecipeTotalTime<S>>) -> Self {
        self._fields.134 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `translationOfWork` field (optional)
    pub fn translation_of_work(
        mut self,
        value: impl Into<Option<RecipeTranslationOfWork<S>>>,
    ) -> Self {
        self._fields.135 = value.into();
        self
    }
    /// Set the `translationOfWork` field to an Option value (optional)
    pub fn maybe_translation_of_work(
        mut self,
        value: Option<RecipeTranslationOfWork<S>>,
    ) -> Self {
        self._fields.135 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `translator` field (optional)
    pub fn translator(mut self, value: impl Into<Option<RecipeTranslator<S>>>) -> Self {
        self._fields.136 = value.into();
        self
    }
    /// Set the `translator` field to an Option value (optional)
    pub fn maybe_translator(mut self, value: Option<RecipeTranslator<S>>) -> Self {
        self._fields.136 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `typicalAgeRange` field (optional)
    pub fn typical_age_range(
        mut self,
        value: impl Into<Option<RecipeTypicalAgeRange<S>>>,
    ) -> Self {
        self._fields.137 = value.into();
        self
    }
    /// Set the `typicalAgeRange` field to an Option value (optional)
    pub fn maybe_typical_age_range(
        mut self,
        value: Option<RecipeTypicalAgeRange<S>>,
    ) -> Self {
        self._fields.137 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `url` field (optional)
    pub fn url(mut self, value: impl Into<Option<RecipeUrl<S>>>) -> Self {
        self._fields.138 = value.into();
        self
    }
    /// Set the `url` field to an Option value (optional)
    pub fn maybe_url(mut self, value: Option<RecipeUrl<S>>) -> Self {
        self._fields.138 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `usageInfo` field (optional)
    pub fn usage_info(mut self, value: impl Into<Option<RecipeUsageInfo<S>>>) -> Self {
        self._fields.139 = value.into();
        self
    }
    /// Set the `usageInfo` field to an Option value (optional)
    pub fn maybe_usage_info(mut self, value: Option<RecipeUsageInfo<S>>) -> Self {
        self._fields.139 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `version` field (optional)
    pub fn version(mut self, value: impl Into<Option<RecipeVersion<S>>>) -> Self {
        self._fields.140 = value.into();
        self
    }
    /// Set the `version` field to an Option value (optional)
    pub fn maybe_version(mut self, value: Option<RecipeVersion<S>>) -> Self {
        self._fields.140 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `video` field (optional)
    pub fn video(mut self, value: impl Into<Option<RecipeVideo<S>>>) -> Self {
        self._fields.141 = value.into();
        self
    }
    /// Set the `video` field to an Option value (optional)
    pub fn maybe_video(mut self, value: Option<RecipeVideo<S>>) -> Self {
        self._fields.141 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `wordCount` field (optional)
    pub fn word_count(mut self, value: impl Into<Option<RecipeWordCount<S>>>) -> Self {
        self._fields.142 = value.into();
        self
    }
    /// Set the `wordCount` field to an Option value (optional)
    pub fn maybe_word_count(mut self, value: Option<RecipeWordCount<S>>) -> Self {
        self._fields.142 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `workExample` field (optional)
    pub fn work_example(
        mut self,
        value: impl Into<Option<RecipeWorkExample<S>>>,
    ) -> Self {
        self._fields.143 = value.into();
        self
    }
    /// Set the `workExample` field to an Option value (optional)
    pub fn maybe_work_example(mut self, value: Option<RecipeWorkExample<S>>) -> Self {
        self._fields.143 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `workTranslation` field (optional)
    pub fn work_translation(
        mut self,
        value: impl Into<Option<RecipeWorkTranslation<S>>>,
    ) -> Self {
        self._fields.144 = value.into();
        self
    }
    /// Set the `workTranslation` field to an Option value (optional)
    pub fn maybe_work_translation(
        mut self,
        value: Option<RecipeWorkTranslation<S>>,
    ) -> Self {
        self._fields.144 = value;
        self
    }
}

impl<St: recipe_state::State, S: BosStr> RecipeBuilder<St, S> {
    /// Set the `yield` field (optional)
    pub fn r#yield(mut self, value: impl Into<Option<RecipeYield<S>>>) -> Self {
        self._fields.145 = value.into();
        self
    }
    /// Set the `yield` field to an Option value (optional)
    pub fn maybe_yield(mut self, value: Option<RecipeYield<S>>) -> Self {
        self._fields.145 = value;
        self
    }
}

impl<St, S: BosStr> RecipeBuilder<St, S>
where
    St: recipe_state::State,
{
    /// Build the final struct.
    pub fn build(self) -> Recipe<S> {
        Recipe {
            about: self._fields.0,
            r#abstract: self._fields.1,
            access_mode: self._fields.2,
            access_mode_sufficient: self._fields.3,
            accessibility_api: self._fields.4,
            accessibility_control: self._fields.5,
            accessibility_feature: self._fields.6,
            accessibility_hazard: self._fields.7,
            accessibility_summary: self._fields.8,
            accountable_person: self._fields.9,
            acquire_license_page: self._fields.10,
            additional_type: self._fields.11,
            aggregate_rating: self._fields.12,
            alternate_name: self._fields.13,
            alternative_headline: self._fields.14,
            archived_at: self._fields.15,
            assesses: self._fields.16,
            associated_media: self._fields.17,
            audience: self._fields.18,
            audio: self._fields.19,
            author: self._fields.20,
            award: self._fields.21,
            awards: self._fields.22,
            character: self._fields.23,
            citation: self._fields.24,
            comment: self._fields.25,
            comment_count: self._fields.26,
            conditions_of_access: self._fields.27,
            content_location: self._fields.28,
            content_rating: self._fields.29,
            content_reference_time: self._fields.30,
            contributor: self._fields.31,
            cook_time: self._fields.32,
            cooking_method: self._fields.33,
            copyright_holder: self._fields.34,
            copyright_notice: self._fields.35,
            copyright_year: self._fields.36,
            correction: self._fields.37,
            country_of_origin: self._fields.38,
            creative_work_status: self._fields.39,
            creator: self._fields.40,
            credit_text: self._fields.41,
            date_created: self._fields.42,
            date_modified: self._fields.43,
            date_published: self._fields.44,
            description: self._fields.45,
            digital_source_type: self._fields.46,
            disambiguating_description: self._fields.47,
            discussion_url: self._fields.48,
            edit_eidr: self._fields.49,
            editor: self._fields.50,
            educational_alignment: self._fields.51,
            educational_level: self._fields.52,
            educational_use: self._fields.53,
            encoding: self._fields.54,
            encoding_format: self._fields.55,
            encodings: self._fields.56,
            estimated_cost: self._fields.57,
            example_of_work: self._fields.58,
            expires: self._fields.59,
            file_format: self._fields.60,
            funder: self._fields.61,
            funding: self._fields.62,
            genre: self._fields.63,
            has_part: self._fields.64,
            headline: self._fields.65,
            identifier: self._fields.66,
            image: self._fields.67,
            in_language: self._fields.68,
            ingredients: self._fields.69,
            interaction_statistic: self._fields.70,
            interactivity_type: self._fields.71,
            interpreted_as_claim: self._fields.72,
            is_accessible_for_free: self._fields.73,
            is_based_on: self._fields.74,
            is_based_on_url: self._fields.75,
            is_family_friendly: self._fields.76,
            is_part_of: self._fields.77,
            keywords: self._fields.78,
            learning_resource_type: self._fields.79,
            license: self._fields.80,
            location_created: self._fields.81,
            main_entity: self._fields.82,
            main_entity_of_page: self._fields.83,
            maintainer: self._fields.84,
            material: self._fields.85,
            material_extent: self._fields.86,
            mentions: self._fields.87,
            name: self._fields.88,
            nutrition: self._fields.89,
            offers: self._fields.90,
            pattern: self._fields.91,
            perform_time: self._fields.92,
            position: self._fields.93,
            potential_action: self._fields.94,
            prep_time: self._fields.95,
            producer: self._fields.96,
            provider: self._fields.97,
            publication: self._fields.98,
            publisher: self._fields.99,
            publisher_imprint: self._fields.100,
            publishing_principles: self._fields.101,
            recipe_category: self._fields.102,
            recipe_cuisine: self._fields.103,
            recipe_ingredient: self._fields.104,
            recipe_instructions: self._fields.105,
            recipe_yield: self._fields.106,
            recorded_at: self._fields.107,
            released_event: self._fields.108,
            review: self._fields.109,
            reviews: self._fields.110,
            same_as: self._fields.111,
            schema_version: self._fields.112,
            sd_date_published: self._fields.113,
            sd_license: self._fields.114,
            sd_publisher: self._fields.115,
            size: self._fields.116,
            source_organization: self._fields.117,
            spatial: self._fields.118,
            spatial_coverage: self._fields.119,
            sponsor: self._fields.120,
            step: self._fields.121,
            steps: self._fields.122,
            subject_of: self._fields.123,
            suitable_for_diet: self._fields.124,
            supply: self._fields.125,
            teaches: self._fields.126,
            temporal: self._fields.127,
            temporal_coverage: self._fields.128,
            text: self._fields.129,
            thumbnail: self._fields.130,
            thumbnail_url: self._fields.131,
            time_required: self._fields.132,
            tool: self._fields.133,
            total_time: self._fields.134,
            translation_of_work: self._fields.135,
            translator: self._fields.136,
            typical_age_range: self._fields.137,
            url: self._fields.138,
            usage_info: self._fields.139,
            version: self._fields.140,
            video: self._fields.141,
            word_count: self._fields.142,
            work_example: self._fields.143,
            work_translation: self._fields.144,
            r#yield: self._fields.145,
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data.
    pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> Recipe<S> {
        Recipe {
            about: self._fields.0,
            r#abstract: self._fields.1,
            access_mode: self._fields.2,
            access_mode_sufficient: self._fields.3,
            accessibility_api: self._fields.4,
            accessibility_control: self._fields.5,
            accessibility_feature: self._fields.6,
            accessibility_hazard: self._fields.7,
            accessibility_summary: self._fields.8,
            accountable_person: self._fields.9,
            acquire_license_page: self._fields.10,
            additional_type: self._fields.11,
            aggregate_rating: self._fields.12,
            alternate_name: self._fields.13,
            alternative_headline: self._fields.14,
            archived_at: self._fields.15,
            assesses: self._fields.16,
            associated_media: self._fields.17,
            audience: self._fields.18,
            audio: self._fields.19,
            author: self._fields.20,
            award: self._fields.21,
            awards: self._fields.22,
            character: self._fields.23,
            citation: self._fields.24,
            comment: self._fields.25,
            comment_count: self._fields.26,
            conditions_of_access: self._fields.27,
            content_location: self._fields.28,
            content_rating: self._fields.29,
            content_reference_time: self._fields.30,
            contributor: self._fields.31,
            cook_time: self._fields.32,
            cooking_method: self._fields.33,
            copyright_holder: self._fields.34,
            copyright_notice: self._fields.35,
            copyright_year: self._fields.36,
            correction: self._fields.37,
            country_of_origin: self._fields.38,
            creative_work_status: self._fields.39,
            creator: self._fields.40,
            credit_text: self._fields.41,
            date_created: self._fields.42,
            date_modified: self._fields.43,
            date_published: self._fields.44,
            description: self._fields.45,
            digital_source_type: self._fields.46,
            disambiguating_description: self._fields.47,
            discussion_url: self._fields.48,
            edit_eidr: self._fields.49,
            editor: self._fields.50,
            educational_alignment: self._fields.51,
            educational_level: self._fields.52,
            educational_use: self._fields.53,
            encoding: self._fields.54,
            encoding_format: self._fields.55,
            encodings: self._fields.56,
            estimated_cost: self._fields.57,
            example_of_work: self._fields.58,
            expires: self._fields.59,
            file_format: self._fields.60,
            funder: self._fields.61,
            funding: self._fields.62,
            genre: self._fields.63,
            has_part: self._fields.64,
            headline: self._fields.65,
            identifier: self._fields.66,
            image: self._fields.67,
            in_language: self._fields.68,
            ingredients: self._fields.69,
            interaction_statistic: self._fields.70,
            interactivity_type: self._fields.71,
            interpreted_as_claim: self._fields.72,
            is_accessible_for_free: self._fields.73,
            is_based_on: self._fields.74,
            is_based_on_url: self._fields.75,
            is_family_friendly: self._fields.76,
            is_part_of: self._fields.77,
            keywords: self._fields.78,
            learning_resource_type: self._fields.79,
            license: self._fields.80,
            location_created: self._fields.81,
            main_entity: self._fields.82,
            main_entity_of_page: self._fields.83,
            maintainer: self._fields.84,
            material: self._fields.85,
            material_extent: self._fields.86,
            mentions: self._fields.87,
            name: self._fields.88,
            nutrition: self._fields.89,
            offers: self._fields.90,
            pattern: self._fields.91,
            perform_time: self._fields.92,
            position: self._fields.93,
            potential_action: self._fields.94,
            prep_time: self._fields.95,
            producer: self._fields.96,
            provider: self._fields.97,
            publication: self._fields.98,
            publisher: self._fields.99,
            publisher_imprint: self._fields.100,
            publishing_principles: self._fields.101,
            recipe_category: self._fields.102,
            recipe_cuisine: self._fields.103,
            recipe_ingredient: self._fields.104,
            recipe_instructions: self._fields.105,
            recipe_yield: self._fields.106,
            recorded_at: self._fields.107,
            released_event: self._fields.108,
            review: self._fields.109,
            reviews: self._fields.110,
            same_as: self._fields.111,
            schema_version: self._fields.112,
            sd_date_published: self._fields.113,
            sd_license: self._fields.114,
            sd_publisher: self._fields.115,
            size: self._fields.116,
            source_organization: self._fields.117,
            spatial: self._fields.118,
            spatial_coverage: self._fields.119,
            sponsor: self._fields.120,
            step: self._fields.121,
            steps: self._fields.122,
            subject_of: self._fields.123,
            suitable_for_diet: self._fields.124,
            supply: self._fields.125,
            teaches: self._fields.126,
            temporal: self._fields.127,
            temporal_coverage: self._fields.128,
            text: self._fields.129,
            thumbnail: self._fields.130,
            thumbnail_url: self._fields.131,
            time_required: self._fields.132,
            tool: self._fields.133,
            total_time: self._fields.134,
            translation_of_work: self._fields.135,
            translator: self._fields.136,
            typical_age_range: self._fields.137,
            url: self._fields.138,
            usage_info: self._fields.139,
            version: self._fields.140,
            video: self._fields.141,
            word_count: self._fields.142,
            work_example: self._fields.143,
            work_translation: self._fields.144,
            r#yield: self._fields.145,
            extra_data: Some(extra_data),
        }
    }
}