// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: social.flockfeeds.lexical.type.Episode
//
// 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;
use jacquard_common::{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::value::Data;
use jacquard_derive::{IntoStatic, 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::music_group;
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 media episode (e.g. TV, radio, video game) which can be part of a series or season.

#[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 actor: Option<EmbeddedActor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub actors: Option<EmbeddedActors<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 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 director: Option<EmbeddedDirector<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub directors: Option<EmbeddedDirectors<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 duration: Option<EmbeddedDuration<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 episode_number: Option<EmbeddedEpisodeNumber<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 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 music_by: Option<EmbeddedMusicBy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<EmbeddedName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offers: Option<EmbeddedOffers<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub part_of_season: Option<EmbeddedPartOfSeason<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub part_of_series: Option<EmbeddedPartOfSeries<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<EmbeddedPattern<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 producer: Option<EmbeddedProducer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub production_company: Option<EmbeddedProductionCompany<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 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 subject_of: Option<EmbeddedSubjectOf<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 trailer: Option<EmbeddedTrailer<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(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 EmbeddedActor<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 EmbeddedActors<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 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 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 EmbeddedDirector<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 EmbeddedDirectors<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 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 EmbeddedDuration<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 EmbeddedEpisodeNumber<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 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 EmbeddedMusicBy<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.MusicGroup#embedded")]
    MusicGroupEmbedded(Box<music_group::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 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 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 EmbeddedPartOfSeason<S: BosStr = DefaultStr> {}

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

#[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 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 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 EmbeddedProductionCompany<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 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 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 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 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 EmbeddedTrailer<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> {}
/// A media episode (e.g. TV, radio, video game) which can be part of a series or season.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct Episode<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub about: Option<EpisodeAbout<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#abstract: Option<EpisodeAbstract<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub access_mode: Option<EpisodeAccessMode<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub access_mode_sufficient: Option<EpisodeAccessModeSufficient<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_api: Option<EpisodeAccessibilityApi<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_control: Option<EpisodeAccessibilityControl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_feature: Option<EpisodeAccessibilityFeature<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_hazard: Option<EpisodeAccessibilityHazard<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accessibility_summary: Option<EpisodeAccessibilitySummary<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accountable_person: Option<EpisodeAccountablePerson<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub acquire_license_page: Option<EpisodeAcquireLicensePage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub actor: Option<EpisodeActor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub actors: Option<EpisodeActors<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_type: Option<EpisodeAdditionalType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aggregate_rating: Option<EpisodeAggregateRating<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternate_name: Option<EpisodeAlternateName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternative_headline: Option<EpisodeAlternativeHeadline<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub archived_at: Option<EpisodeArchivedAt<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub assesses: Option<EpisodeAssesses<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub associated_media: Option<EpisodeAssociatedMedia<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audience: Option<EpisodeAudience<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audio: Option<EpisodeAudio<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub author: Option<EpisodeAuthor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub award: Option<EpisodeAward<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awards: Option<EpisodeAwards<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub character: Option<EpisodeCharacter<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub citation: Option<EpisodeCitation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<EpisodeComment<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment_count: Option<EpisodeCommentCount<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conditions_of_access: Option<EpisodeConditionsOfAccess<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_location: Option<EpisodeContentLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_rating: Option<EpisodeContentRating<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_reference_time: Option<EpisodeContentReferenceTime<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contributor: Option<EpisodeContributor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_holder: Option<EpisodeCopyrightHolder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_notice: Option<EpisodeCopyrightNotice<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub copyright_year: Option<EpisodeCopyrightYear<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correction: Option<EpisodeCorrection<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_of_origin: Option<EpisodeCountryOfOrigin<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creative_work_status: Option<EpisodeCreativeWorkStatus<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creator: Option<EpisodeCreator<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub credit_text: Option<EpisodeCreditText<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_created: Option<EpisodeDateCreated<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_modified: Option<EpisodeDateModified<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_published: Option<EpisodeDatePublished<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<EpisodeDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digital_source_type: Option<EpisodeDigitalSourceType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub director: Option<EpisodeDirector<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub directors: Option<EpisodeDirectors<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disambiguating_description: Option<EpisodeDisambiguatingDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub discussion_url: Option<EpisodeDiscussionUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duration: Option<EpisodeDuration<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_eidr: Option<EpisodeEditEidr<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor: Option<EpisodeEditor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_alignment: Option<EpisodeEducationalAlignment<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_level: Option<EpisodeEducationalLevel<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub educational_use: Option<EpisodeEducationalUse<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding: Option<EpisodeEncoding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding_format: Option<EpisodeEncodingFormat<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encodings: Option<EpisodeEncodings<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub episode_number: Option<EpisodeEpisodeNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub example_of_work: Option<EpisodeExampleOfWork<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires: Option<EpisodeExpires<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_format: Option<EpisodeFileFormat<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funder: Option<EpisodeFunder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funding: Option<EpisodeFunding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub genre: Option<EpisodeGenre<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_part: Option<EpisodeHasPart<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub headline: Option<EpisodeHeadline<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifier: Option<EpisodeIdentifier<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<EpisodeImage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub in_language: Option<EpisodeInLanguage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interaction_statistic: Option<EpisodeInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interactivity_type: Option<EpisodeInteractivityType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpreted_as_claim: Option<EpisodeInterpretedAsClaim<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_accessible_for_free: Option<EpisodeIsAccessibleForFree<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_based_on: Option<EpisodeIsBasedOn<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_based_on_url: Option<EpisodeIsBasedOnUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_family_friendly: Option<EpisodeIsFamilyFriendly<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_part_of: Option<EpisodeIsPartOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub keywords: Option<EpisodeKeywords<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub learning_resource_type: Option<EpisodeLearningResourceType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub license: Option<EpisodeLicense<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_created: Option<EpisodeLocationCreated<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity: Option<EpisodeMainEntity<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity_of_page: Option<EpisodeMainEntityOfPage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maintainer: Option<EpisodeMaintainer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub material: Option<EpisodeMaterial<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub material_extent: Option<EpisodeMaterialExtent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mentions: Option<EpisodeMentions<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_by: Option<EpisodeMusicBy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<EpisodeName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offers: Option<EpisodeOffers<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub part_of_season: Option<EpisodePartOfSeason<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub part_of_series: Option<EpisodePartOfSeries<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<EpisodePattern<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub position: Option<EpisodePosition<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub potential_action: Option<EpisodePotentialAction<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub producer: Option<EpisodeProducer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub production_company: Option<EpisodeProductionCompany<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<EpisodeProvider<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publication: Option<EpisodePublication<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher: Option<EpisodePublisher<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher_imprint: Option<EpisodePublisherImprint<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publishing_principles: Option<EpisodePublishingPrinciples<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recorded_at: Option<EpisodeRecordedAt<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub released_event: Option<EpisodeReleasedEvent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub review: Option<EpisodeReview<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reviews: Option<EpisodeReviews<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub same_as: Option<EpisodeSameAs<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub schema_version: Option<EpisodeSchemaVersion<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_date_published: Option<EpisodeSdDatePublished<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_license: Option<EpisodeSdLicense<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sd_publisher: Option<EpisodeSdPublisher<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<EpisodeSize<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_organization: Option<EpisodeSourceOrganization<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spatial: Option<EpisodeSpatial<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spatial_coverage: Option<EpisodeSpatialCoverage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sponsor: Option<EpisodeSponsor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject_of: Option<EpisodeSubjectOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub teaches: Option<EpisodeTeaches<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temporal: Option<EpisodeTemporal<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temporal_coverage: Option<EpisodeTemporalCoverage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub text: Option<EpisodeText<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thumbnail: Option<EpisodeThumbnail<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thumbnail_url: Option<EpisodeThumbnailUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time_required: Option<EpisodeTimeRequired<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trailer: Option<EpisodeTrailer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation_of_work: Option<EpisodeTranslationOfWork<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translator: Option<EpisodeTranslator<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub typical_age_range: Option<EpisodeTypicalAgeRange<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<EpisodeUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub usage_info: Option<EpisodeUsageInfo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<EpisodeVersion<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub video: Option<EpisodeVideo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub word_count: Option<EpisodeWordCount<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_example: Option<EpisodeWorkExample<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_translation: Option<EpisodeWorkTranslation<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 EpisodeAbout<S: BosStr = DefaultStr> {}

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

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

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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeActor<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 EpisodeActors<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 EpisodeAdditionalType<S: BosStr = DefaultStr> {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeContributor<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 EpisodeCopyrightHolder<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 EpisodeCopyrightNotice<S: BosStr = DefaultStr> {}

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

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

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

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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeDirector<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 EpisodeDirectors<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 EpisodeDisambiguatingDescription<S: BosStr = DefaultStr> {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeIsBasedOn<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 EpisodeIsBasedOnUrl<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 EpisodeIsFamilyFriendly<S: BosStr = DefaultStr> {}

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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeMaintainer<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 EpisodeMaterial<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 EpisodeMaterialExtent<S: BosStr = DefaultStr> {}

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeMusicBy<S: BosStr = DefaultStr> {
    #[serde(rename = "social.flockfeeds.lexical.type.MusicGroup#embedded")]
    MusicGroupEmbedded(Box<music_group::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 EpisodeName<S: BosStr = DefaultStr> {}

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeProducer<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 EpisodeProductionCompany<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 EpisodeProvider<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 EpisodePublication<S: BosStr = DefaultStr> {}

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodePublisher<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 EpisodePublisherImprint<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 EpisodePublishingPrinciples<S: BosStr = DefaultStr> {}

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

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

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

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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeSponsor<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 EpisodeSubjectOf<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 EpisodeTeaches<S: BosStr = DefaultStr> {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum EpisodeWorkTranslation<S: BosStr = DefaultStr> {}
impl<S: BosStr> LexiconSchema for Embedded<S> {
    fn nsid() -> &'static str {
        "social.flockfeeds.lexical.type.Episode"
    }
    fn def_name() -> &'static str {
        "embedded"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_social_flockfeeds_lexical_type_Episode()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

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

fn lexicon_doc_social_flockfeeds_lexical_type_Episode() -> 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.Episode"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("embedded"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "A media episode (e.g. TV, radio, video game) which can be part of a series or season.",
                        ),
                    ),
                    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.episode#aboutList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("abstract"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#abstractScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#abstractList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessMode"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessModeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#accessModeSufficientList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityAPI"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityAPIScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityAPIList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityControl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityControlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityControlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityFeature"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityFeatureScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityFeatureList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityHazard"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityHazardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityHazardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilitySummary"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilitySummaryScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#acquireLicensePageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#acquireLicensePageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("actor"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PerformingGroup#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#actorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("actors"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#actorsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("additionalType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#additionalTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#aggregateRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternateName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#alternateNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#alternateNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternativeHeadline"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#alternativeHeadlineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#archivedAtScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#assessesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#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.episode#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.episode#authorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("award"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#awardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#awardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("awards"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#awardsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#citationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#commentList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("commentCount"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#commentCountScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#commentCountList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("conditionsOfAccess"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#conditionsOfAccessScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#contentRatingScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#contentRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contentReferenceTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#contentReferenceTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#contributorList")
                                ],
                                ..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.episode#copyrightHolderList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightNotice"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#copyrightNoticeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#copyrightNoticeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightYear"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#copyrightYearScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#correctionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#creativeWorkStatusScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#creatorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("creditText"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#creditTextScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#creditTextList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dateCreated"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#dateCreatedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#dateCreatedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dateModified"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#dateModifiedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#dateModifiedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("datePublished"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#datePublishedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#descriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#digitalSourceTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#digitalSourceTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("director"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#directorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("directors"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#directorsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("disambiguatingDescription"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#disambiguatingDescriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#disambiguatingDescriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("discussionUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#discussionUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#discussionUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("duration"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#durationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#durationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("editEIDR"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#editEIDRScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#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.episode#educationalLevelScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#educationalUseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#encodingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("encodingFormat"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#encodingFormatScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#encodingsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("episodeNumber"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#episodeNumberScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#episodeNumberList")
                                ],
                                ..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.episode#exampleOfWorkList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("expires"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#expiresScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#expiresList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("fileFormat"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#fileFormatScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#fundingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("genre"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#genreScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#hasPartList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("headline"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#headlineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#identifierScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#imageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#inLanguageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#inLanguageList")
                                ],
                                ..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.episode#interactionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("interactivityType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#interactivityTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#interpretedAsClaimList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isAccessibleForFree"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#isAccessibleForFreeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#isBasedOnScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#isBasedOnUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#isBasedOnUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isFamilyFriendly"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#isFamilyFriendlyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#isPartOfScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#keywordsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#learningResourceTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#licenseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#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.episode#mainEntityOfPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#materialScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#materialExtentScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#mentionsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("musicBy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MusicGroup#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#musicByList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#nameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#nameList")
                                ],
                                ..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.episode#offersList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("partOfSeason"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWorkSeason#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#partOfSeasonList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("partOfSeries"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWorkSeries#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#partOfSeriesList")
                                ],
                                ..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.episode#patternScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#patternList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("position"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#positionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#potentialActionList")
                                ],
                                ..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.episode#producerList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("productionCompany"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#productionCompanyList")
                                ],
                                ..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.episode#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.episode#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.episode#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.episode#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.episode#publishingPrinciplesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#publishingPrinciplesList")
                                ],
                                ..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.episode#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.episode#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.episode#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.episode#reviewsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sameAs"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#sameAsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#sameAsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("schemaVersion"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#schemaVersionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#schemaVersionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sdDatePublished"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#sdDatePublishedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#sdLicenseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#sizeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#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.episode#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.episode#sponsorList")
                                ],
                                ..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.episode#subjectOfList")
                                ],
                                ..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.episode#teachesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#teachesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("temporal"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#temporalScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#temporalList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("temporalCoverage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#temporalCoverageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#temporalCoverageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("text"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#textScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#thumbnailList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("thumbnailUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#thumbnailUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#thumbnailUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("timeRequired"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#timeRequiredScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#timeRequiredList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("trailer"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.VideoObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#trailerList")
                                ],
                                ..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.episode#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.episode#translatorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("typicalAgeRange"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#typicalAgeRangeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#typicalAgeRangeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("url"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#urlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#usageInfoScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#usageInfoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("version"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#versionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#videoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("wordCount"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#wordCountScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#workTranslationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("main"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "A media episode (e.g. TV, radio, video game) which can be part of a series or season.",
                        ),
                    ),
                    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.episode#aboutList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("abstract"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#abstractScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#abstractList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessMode"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessModeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#accessModeSufficientList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityAPI"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityAPIScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityAPIList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityControl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityControlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityControlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityFeature"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityFeatureScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityFeatureList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityHazard"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityHazardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilityHazardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilitySummary"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#accessibilitySummaryScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#acquireLicensePageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#acquireLicensePageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("actor"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PerformingGroup#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#actorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("actors"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#actorsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("additionalType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#additionalTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#aggregateRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternateName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#alternateNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#alternateNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternativeHeadline"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#alternativeHeadlineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#archivedAtScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#assessesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#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.episode#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.episode#authorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("award"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#awardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#awardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("awards"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#awardsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#citationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#commentList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("commentCount"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#commentCountScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#commentCountList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("conditionsOfAccess"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#conditionsOfAccessScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#contentRatingScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#contentRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contentReferenceTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#contentReferenceTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#contributorList")
                                ],
                                ..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.episode#copyrightHolderList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightNotice"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#copyrightNoticeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#copyrightNoticeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightYear"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#copyrightYearScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#correctionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#creativeWorkStatusScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#creatorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("creditText"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#creditTextScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#creditTextList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dateCreated"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#dateCreatedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#dateCreatedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dateModified"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#dateModifiedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#dateModifiedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("datePublished"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#datePublishedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#descriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#digitalSourceTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#digitalSourceTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("director"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#directorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("directors"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#directorsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("disambiguatingDescription"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#disambiguatingDescriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#disambiguatingDescriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("discussionUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#discussionUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#discussionUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("duration"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#durationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#durationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("editEIDR"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#editEIDRScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#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.episode#educationalLevelScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#educationalUseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#encodingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("encodingFormat"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#encodingFormatScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#encodingsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("episodeNumber"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#episodeNumberScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#episodeNumberList")
                                ],
                                ..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.episode#exampleOfWorkList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("expires"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#expiresScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#expiresList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("fileFormat"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#fileFormatScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#fundingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("genre"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#genreScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#hasPartList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("headline"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#headlineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#identifierScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#imageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#inLanguageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#inLanguageList")
                                ],
                                ..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.episode#interactionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("interactivityType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#interactivityTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#interpretedAsClaimList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isAccessibleForFree"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#isAccessibleForFreeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#isBasedOnScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#isBasedOnUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#isBasedOnUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isFamilyFriendly"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#isFamilyFriendlyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#isPartOfScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#keywordsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#learningResourceTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#licenseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#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.episode#mainEntityOfPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#materialScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#materialExtentScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#mentionsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("musicBy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MusicGroup#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#musicByList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#nameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#nameList")
                                ],
                                ..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.episode#offersList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("partOfSeason"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWorkSeason#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#partOfSeasonList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("partOfSeries"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWorkSeries#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#partOfSeriesList")
                                ],
                                ..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.episode#patternScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#patternList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("position"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#positionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#potentialActionList")
                                ],
                                ..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.episode#producerList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("productionCompany"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#productionCompanyList")
                                ],
                                ..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.episode#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.episode#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.episode#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.episode#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.episode#publishingPrinciplesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#publishingPrinciplesList")
                                ],
                                ..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.episode#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.episode#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.episode#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.episode#reviewsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sameAs"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#sameAsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#sameAsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("schemaVersion"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#schemaVersionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#schemaVersionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sdDatePublished"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#sdDatePublishedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#sdLicenseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#sizeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#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.episode#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.episode#sponsorList")
                                ],
                                ..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.episode#subjectOfList")
                                ],
                                ..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.episode#teachesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#teachesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("temporal"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#temporalScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#temporalList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("temporalCoverage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#temporalCoverageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#temporalCoverageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("text"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#textScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#thumbnailList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("thumbnailUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#thumbnailUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#thumbnailUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("timeRequired"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#timeRequiredScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#timeRequiredList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("trailer"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.VideoObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#trailerList")
                                ],
                                ..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.episode#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.episode#translatorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("typicalAgeRange"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#typicalAgeRangeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#typicalAgeRangeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("url"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#urlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#usageInfoScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#usageInfoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("version"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#versionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#videoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("wordCount"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#wordCountScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.episode#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.episode#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.episode#workTranslationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}