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

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

#[allow(unused_imports)]
use core::marker::PhantomData;
use jacquard_common::CowStr;

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

#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Serialize, Deserialize};
use crate::social_flockfeeds::lexical::r#type::event;
use crate::social_flockfeeds::lexical::r#type::image_object;
use crate::social_flockfeeds::lexical::r#type::news_article;
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;
/// An image file.

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct Embedded<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub about: Option<EmbeddedAbout<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub r#abstract: Option<EmbeddedAbstract<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub access_mode: Option<EmbeddedAccessMode<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub access_mode_sufficient: Option<EmbeddedAccessModeSufficient<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_api: Option<EmbeddedAccessibilityApi<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_control: Option<EmbeddedAccessibilityControl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_feature: Option<EmbeddedAccessibilityFeature<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_hazard: Option<EmbeddedAccessibilityHazard<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_summary: Option<EmbeddedAccessibilitySummary<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accountable_person: Option<EmbeddedAccountablePerson<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub acquire_license_page: Option<EmbeddedAcquireLicensePage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub additional_type: Option<EmbeddedAdditionalType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub aggregate_rating: Option<EmbeddedAggregateRating<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alternate_name: Option<EmbeddedAlternateName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alternative_headline: Option<EmbeddedAlternativeHeadline<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub archived_at: Option<EmbeddedArchivedAt<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub assesses: Option<EmbeddedAssesses<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub associated_article: Option<EmbeddedAssociatedArticle<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub associated_media: Option<EmbeddedAssociatedMedia<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub audience: Option<EmbeddedAudience<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub audio: Option<EmbeddedAudio<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub author: Option<EmbeddedAuthor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub award: Option<EmbeddedAward<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub awards: Option<EmbeddedAwards<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub bitrate: Option<EmbeddedBitrate<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub caption: Option<EmbeddedCaption<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub character: Option<EmbeddedCharacter<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub citation: Option<EmbeddedCitation<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub comment: Option<EmbeddedComment<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub comment_count: Option<EmbeddedCommentCount<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub conditions_of_access: Option<EmbeddedConditionsOfAccess<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_location: Option<EmbeddedContentLocation<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_rating: Option<EmbeddedContentRating<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_reference_time: Option<EmbeddedContentReferenceTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_size: Option<EmbeddedContentSize<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_url: Option<EmbeddedContentUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contributor: Option<EmbeddedContributor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub copyright_holder: Option<EmbeddedCopyrightHolder<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub copyright_notice: Option<EmbeddedCopyrightNotice<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub copyright_year: Option<EmbeddedCopyrightYear<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub correction: Option<EmbeddedCorrection<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub country_of_origin: Option<EmbeddedCountryOfOrigin<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub creative_work_status: Option<EmbeddedCreativeWorkStatus<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub creator: Option<EmbeddedCreator<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub credit_text: Option<EmbeddedCreditText<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub date_created: Option<EmbeddedDateCreated<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub date_modified: Option<EmbeddedDateModified<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub date_published: Option<EmbeddedDatePublished<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description: Option<EmbeddedDescription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub digital_source_type: Option<EmbeddedDigitalSourceType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub disambiguating_description: Option<EmbeddedDisambiguatingDescription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub discussion_url: Option<EmbeddedDiscussionUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub duration: Option<EmbeddedDuration<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub edit_eidr: Option<EmbeddedEditEidr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub editor: Option<EmbeddedEditor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub educational_alignment: Option<EmbeddedEducationalAlignment<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub educational_level: Option<EmbeddedEducationalLevel<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub educational_use: Option<EmbeddedEducationalUse<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub embed_url: Option<EmbeddedEmbedUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub embedded_text_caption: Option<EmbeddedEmbeddedTextCaption<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub encodes_creative_work: Option<EmbeddedEncodesCreativeWork<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub encoding: Option<EmbeddedEncoding<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub encoding_format: Option<EmbeddedEncodingFormat<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub encodings: Option<EmbeddedEncodings<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub end_time: Option<EmbeddedEndTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub example_of_work: Option<EmbeddedExampleOfWork<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub exif_data: Option<EmbeddedExifData<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub expires: Option<EmbeddedExpires<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub file_format: Option<EmbeddedFileFormat<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub funder: Option<EmbeddedFunder<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub funding: Option<EmbeddedFunding<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub genre: Option<EmbeddedGenre<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_part: Option<EmbeddedHasPart<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub headline: Option<EmbeddedHeadline<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub height: Option<EmbeddedHeight<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub identifier: Option<EmbeddedIdentifier<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub image: Option<EmbeddedImage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub in_language: Option<EmbeddedInLanguage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub ineligible_region: Option<EmbeddedIneligibleRegion<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub interaction_statistic: Option<EmbeddedInteractionStatistic<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub interactivity_type: Option<EmbeddedInteractivityType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub interpreted_as_claim: Option<EmbeddedInterpretedAsClaim<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_accessible_for_free: Option<EmbeddedIsAccessibleForFree<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_based_on: Option<EmbeddedIsBasedOn<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_based_on_url: Option<EmbeddedIsBasedOnUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_family_friendly: Option<EmbeddedIsFamilyFriendly<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_part_of: Option<EmbeddedIsPartOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub keywords: Option<EmbeddedKeywords<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub learning_resource_type: Option<EmbeddedLearningResourceType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub license: Option<EmbeddedLicense<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub location_created: Option<EmbeddedLocationCreated<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub main_entity: Option<EmbeddedMainEntity<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub main_entity_of_page: Option<EmbeddedMainEntityOfPage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub maintainer: Option<EmbeddedMaintainer<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub material: Option<EmbeddedMaterial<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub material_extent: Option<EmbeddedMaterialExtent<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub mentions: Option<EmbeddedMentions<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub name: Option<EmbeddedName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub offers: Option<EmbeddedOffers<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub pattern: Option<EmbeddedPattern<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub player_type: Option<EmbeddedPlayerType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub position: Option<EmbeddedPosition<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub potential_action: Option<EmbeddedPotentialAction<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub producer: Option<EmbeddedProducer<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub production_company: Option<EmbeddedProductionCompany<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub provider: Option<EmbeddedProvider<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publication: Option<EmbeddedPublication<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publisher: Option<EmbeddedPublisher<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publisher_imprint: Option<EmbeddedPublisherImprint<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publishing_principles: Option<EmbeddedPublishingPrinciples<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub recorded_at: Option<EmbeddedRecordedAt<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub regions_allowed: Option<EmbeddedRegionsAllowed<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub released_event: Option<EmbeddedReleasedEvent<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub representative_of_page: Option<EmbeddedRepresentativeOfPage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub requires_subscription: Option<EmbeddedRequiresSubscription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub review: Option<EmbeddedReview<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub reviews: Option<EmbeddedReviews<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub same_as: Option<EmbeddedSameAs<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub schema_version: Option<EmbeddedSchemaVersion<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sd_date_published: Option<EmbeddedSdDatePublished<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sd_license: Option<EmbeddedSdLicense<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sd_publisher: Option<EmbeddedSdPublisher<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sha256: Option<EmbeddedSha256<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub size: Option<EmbeddedSize<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub source_organization: Option<EmbeddedSourceOrganization<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub spatial: Option<EmbeddedSpatial<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub spatial_coverage: Option<EmbeddedSpatialCoverage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sponsor: Option<EmbeddedSponsor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub start_time: Option<EmbeddedStartTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub subject_of: Option<EmbeddedSubjectOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub teaches: Option<EmbeddedTeaches<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub temporal: Option<EmbeddedTemporal<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub temporal_coverage: Option<EmbeddedTemporalCoverage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub text: Option<EmbeddedText<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub thumbnail: Option<EmbeddedThumbnail<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub thumbnail_url: Option<EmbeddedThumbnailUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub time_required: Option<EmbeddedTimeRequired<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub translation_of_work: Option<EmbeddedTranslationOfWork<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub translator: Option<EmbeddedTranslator<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub typical_age_range: Option<EmbeddedTypicalAgeRange<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub upload_date: Option<EmbeddedUploadDate<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub url: Option<EmbeddedUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub usage_info: Option<EmbeddedUsageInfo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub version: Option<EmbeddedVersion<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub video: Option<EmbeddedVideo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub width: Option<EmbeddedWidth<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub word_count: Option<EmbeddedWordCount<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub work_example: Option<EmbeddedWorkExample<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub work_translation: Option<EmbeddedWorkTranslation<'a>>,
}


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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type")]
#[serde(bound(deserialize = "'de: 'a"))]
pub enum EmbeddedAssociatedArticle<'a> {
    #[serde(rename = "social.flockfeeds.lexical.type.NewsArticle#embedded")]
    NewsArticleEmbedded(Box<news_article::Embedded<'a>>),
}


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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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


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


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

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

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

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


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

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

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

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

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


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


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


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

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


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


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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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


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

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


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

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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct ImageObject<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub about: Option<ImageObjectAbout<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub r#abstract: Option<ImageObjectAbstract<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub access_mode: Option<ImageObjectAccessMode<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub access_mode_sufficient: Option<ImageObjectAccessModeSufficient<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_api: Option<ImageObjectAccessibilityApi<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_control: Option<ImageObjectAccessibilityControl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_feature: Option<ImageObjectAccessibilityFeature<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_hazard: Option<ImageObjectAccessibilityHazard<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accessibility_summary: Option<ImageObjectAccessibilitySummary<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accountable_person: Option<ImageObjectAccountablePerson<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub acquire_license_page: Option<ImageObjectAcquireLicensePage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub additional_type: Option<ImageObjectAdditionalType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub aggregate_rating: Option<ImageObjectAggregateRating<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alternate_name: Option<ImageObjectAlternateName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alternative_headline: Option<ImageObjectAlternativeHeadline<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub archived_at: Option<ImageObjectArchivedAt<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub assesses: Option<ImageObjectAssesses<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub associated_article: Option<ImageObjectAssociatedArticle<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub associated_media: Option<ImageObjectAssociatedMedia<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub audience: Option<ImageObjectAudience<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub audio: Option<ImageObjectAudio<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub author: Option<ImageObjectAuthor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub award: Option<ImageObjectAward<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub awards: Option<ImageObjectAwards<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub bitrate: Option<ImageObjectBitrate<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub caption: Option<ImageObjectCaption<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub character: Option<ImageObjectCharacter<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub citation: Option<ImageObjectCitation<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub comment: Option<ImageObjectComment<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub comment_count: Option<ImageObjectCommentCount<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub conditions_of_access: Option<ImageObjectConditionsOfAccess<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_location: Option<ImageObjectContentLocation<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_rating: Option<ImageObjectContentRating<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_reference_time: Option<ImageObjectContentReferenceTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_size: Option<ImageObjectContentSize<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_url: Option<ImageObjectContentUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contributor: Option<ImageObjectContributor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub copyright_holder: Option<ImageObjectCopyrightHolder<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub copyright_notice: Option<ImageObjectCopyrightNotice<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub copyright_year: Option<ImageObjectCopyrightYear<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub correction: Option<ImageObjectCorrection<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub country_of_origin: Option<ImageObjectCountryOfOrigin<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub creative_work_status: Option<ImageObjectCreativeWorkStatus<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub creator: Option<ImageObjectCreator<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub credit_text: Option<ImageObjectCreditText<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub date_created: Option<ImageObjectDateCreated<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub date_modified: Option<ImageObjectDateModified<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub date_published: Option<ImageObjectDatePublished<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description: Option<ImageObjectDescription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub digital_source_type: Option<ImageObjectDigitalSourceType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub disambiguating_description: Option<ImageObjectDisambiguatingDescription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub discussion_url: Option<ImageObjectDiscussionUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub duration: Option<ImageObjectDuration<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub edit_eidr: Option<ImageObjectEditEidr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub editor: Option<ImageObjectEditor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub educational_alignment: Option<ImageObjectEducationalAlignment<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub educational_level: Option<ImageObjectEducationalLevel<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub educational_use: Option<ImageObjectEducationalUse<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub embed_url: Option<ImageObjectEmbedUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub embedded_text_caption: Option<ImageObjectEmbeddedTextCaption<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub encodes_creative_work: Option<ImageObjectEncodesCreativeWork<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub encoding: Option<ImageObjectEncoding<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub encoding_format: Option<ImageObjectEncodingFormat<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub encodings: Option<ImageObjectEncodings<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub end_time: Option<ImageObjectEndTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub example_of_work: Option<ImageObjectExampleOfWork<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub exif_data: Option<ImageObjectExifData<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub expires: Option<ImageObjectExpires<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub file_format: Option<ImageObjectFileFormat<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub funder: Option<ImageObjectFunder<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub funding: Option<ImageObjectFunding<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub genre: Option<ImageObjectGenre<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_part: Option<ImageObjectHasPart<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub headline: Option<ImageObjectHeadline<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub height: Option<ImageObjectHeight<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub identifier: Option<ImageObjectIdentifier<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub image: Option<ImageObjectImage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub in_language: Option<ImageObjectInLanguage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub ineligible_region: Option<ImageObjectIneligibleRegion<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub interaction_statistic: Option<ImageObjectInteractionStatistic<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub interactivity_type: Option<ImageObjectInteractivityType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub interpreted_as_claim: Option<ImageObjectInterpretedAsClaim<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_accessible_for_free: Option<ImageObjectIsAccessibleForFree<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_based_on: Option<ImageObjectIsBasedOn<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_based_on_url: Option<ImageObjectIsBasedOnUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_family_friendly: Option<ImageObjectIsFamilyFriendly<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_part_of: Option<ImageObjectIsPartOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub keywords: Option<ImageObjectKeywords<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub learning_resource_type: Option<ImageObjectLearningResourceType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub license: Option<ImageObjectLicense<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub location_created: Option<ImageObjectLocationCreated<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub main_entity: Option<ImageObjectMainEntity<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub main_entity_of_page: Option<ImageObjectMainEntityOfPage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub maintainer: Option<ImageObjectMaintainer<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub material: Option<ImageObjectMaterial<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub material_extent: Option<ImageObjectMaterialExtent<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub mentions: Option<ImageObjectMentions<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub name: Option<ImageObjectName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub offers: Option<ImageObjectOffers<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub pattern: Option<ImageObjectPattern<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub player_type: Option<ImageObjectPlayerType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub position: Option<ImageObjectPosition<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub potential_action: Option<ImageObjectPotentialAction<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub producer: Option<ImageObjectProducer<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub production_company: Option<ImageObjectProductionCompany<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub provider: Option<ImageObjectProvider<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publication: Option<ImageObjectPublication<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publisher: Option<ImageObjectPublisher<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publisher_imprint: Option<ImageObjectPublisherImprint<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publishing_principles: Option<ImageObjectPublishingPrinciples<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub recorded_at: Option<ImageObjectRecordedAt<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub regions_allowed: Option<ImageObjectRegionsAllowed<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub released_event: Option<ImageObjectReleasedEvent<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub representative_of_page: Option<ImageObjectRepresentativeOfPage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub requires_subscription: Option<ImageObjectRequiresSubscription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub review: Option<ImageObjectReview<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub reviews: Option<ImageObjectReviews<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub same_as: Option<ImageObjectSameAs<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub schema_version: Option<ImageObjectSchemaVersion<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sd_date_published: Option<ImageObjectSdDatePublished<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sd_license: Option<ImageObjectSdLicense<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sd_publisher: Option<ImageObjectSdPublisher<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sha256: Option<ImageObjectSha256<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub size: Option<ImageObjectSize<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub source_organization: Option<ImageObjectSourceOrganization<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub spatial: Option<ImageObjectSpatial<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub spatial_coverage: Option<ImageObjectSpatialCoverage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sponsor: Option<ImageObjectSponsor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub start_time: Option<ImageObjectStartTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub subject_of: Option<ImageObjectSubjectOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub teaches: Option<ImageObjectTeaches<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub temporal: Option<ImageObjectTemporal<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub temporal_coverage: Option<ImageObjectTemporalCoverage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub text: Option<ImageObjectText<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub thumbnail: Option<ImageObjectThumbnail<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub thumbnail_url: Option<ImageObjectThumbnailUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub time_required: Option<ImageObjectTimeRequired<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub translation_of_work: Option<ImageObjectTranslationOfWork<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub translator: Option<ImageObjectTranslator<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub typical_age_range: Option<ImageObjectTypicalAgeRange<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub upload_date: Option<ImageObjectUploadDate<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub url: Option<ImageObjectUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub usage_info: Option<ImageObjectUsageInfo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub version: Option<ImageObjectVersion<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub video: Option<ImageObjectVideo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub width: Option<ImageObjectWidth<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub word_count: Option<ImageObjectWordCount<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub work_example: Option<ImageObjectWorkExample<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub work_translation: Option<ImageObjectWorkTranslation<'a>>,
}


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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type")]
#[serde(bound(deserialize = "'de: 'a"))]
pub enum ImageObjectAssociatedArticle<'a> {
    #[serde(rename = "social.flockfeeds.lexical.type.NewsArticle#embedded")]
    NewsArticleEmbedded(Box<news_article::Embedded<'a>>),
}


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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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


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


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

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

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

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


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

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

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

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

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


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


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


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

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


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


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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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


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

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


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

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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct ImageObjectGetRecordOutput<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub cid: Option<Cid<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
    #[serde(borrow)]
    pub value: ImageObject<'a>,
}

impl<'a> ImageObject<'a> {
    pub fn uri(
        uri: impl Into<CowStr<'a>>,
    ) -> Result<RecordUri<'a, ImageObjectRecord>, UriError> {
        RecordUri::try_from_uri(AtUri::new_cow(uri.into())?)
    }
}

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

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

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

impl From<ImageObjectGetRecordOutput<'_>> for ImageObject<'_> {
    fn from(output: ImageObjectGetRecordOutput<'_>) -> Self {
        use jacquard_common::IntoStatic;
        output.value.into_static()
    }
}

impl Collection for ImageObject<'_> {
    const NSID: &'static str = "social.flockfeeds.lexical.type.ImageObject";
    type Record = ImageObjectRecord;
}

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

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

fn lexicon_doc_social_flockfeeds_lexical_type_ImageObject() -> 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.ImageObject"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("embedded"),
                LexUserType::Object(LexObject {
                    description: Some(CowStr::new_static("An image file.")),
                    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.imageObject#aboutList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("abstract"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#abstractScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#abstractList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessMode"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessModeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#accessModeSufficientList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityAPI"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityAPIScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityAPIList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityControl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityControlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityControlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityFeature"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityFeatureScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityFeatureList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilityHazard"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityHazardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityHazardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("accessibilitySummary"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilitySummaryScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#acquireLicensePageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#acquireLicensePageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("additionalType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#additionalTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#aggregateRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternateName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#alternateNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#alternateNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternativeHeadline"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#alternativeHeadlineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#archivedAtScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#assessesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#assessesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("associatedArticle"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.NewsArticle#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#associatedArticleList")
                                ],
                                ..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.imageObject#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.imageObject#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.imageObject#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.imageObject#authorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("award"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#awardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#awardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("awards"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#awardsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#awardsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("bitrate"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#bitrateScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#bitrateList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("caption"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MediaObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#captionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#captionList")
                                ],
                                ..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.imageObject#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.imageObject#citationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#commentList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("commentCount"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#commentCountScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#commentCountList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("conditionsOfAccess"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#conditionsOfAccessScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#contentRatingScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contentReferenceTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentReferenceTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentReferenceTimeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contentSize"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentSizeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentSizeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contentUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentUrlList")
                                ],
                                ..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.imageObject#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.imageObject#copyrightHolderList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightNotice"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#copyrightNoticeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#copyrightNoticeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("copyrightYear"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#copyrightYearScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#correctionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#creativeWorkStatusScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#creatorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("creditText"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#creditTextScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#creditTextList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dateCreated"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#dateCreatedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#dateCreatedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dateModified"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#dateModifiedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#dateModifiedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("datePublished"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#datePublishedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#descriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#digitalSourceTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#digitalSourceTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("disambiguatingDescription"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#disambiguatingDescriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#disambiguatingDescriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("discussionUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#discussionUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#durationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#durationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("editEIDR"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#editEIDRScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#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.imageObject#educationalLevelScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#educationalUseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#educationalUseList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("embedUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#embedUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#embedUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("embeddedTextCaption"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#embeddedTextCaptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#embeddedTextCaptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("encodesCreativeWork"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#encodesCreativeWorkList")
                                ],
                                ..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.imageObject#encodingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("encodingFormat"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#encodingFormatScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#encodingsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("endTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#endTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#endTimeList")
                                ],
                                ..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.imageObject#exampleOfWorkList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("exifData"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PropertyValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#exifDataScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#exifDataList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("expires"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#expiresScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#expiresList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("fileFormat"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#fileFormatScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#fundingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("genre"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#genreScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#hasPartList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("headline"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#headlineScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#headlineList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("height"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Distance#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#heightScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#heightList")
                                ],
                                ..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.imageObject#identifierScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#imageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#inLanguageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#inLanguageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("ineligibleRegion"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeoShape#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#ineligibleRegionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#ineligibleRegionList")
                                ],
                                ..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.imageObject#interactionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("interactivityType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#interactivityTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#interpretedAsClaimList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isAccessibleForFree"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#isAccessibleForFreeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#isBasedOnScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#isBasedOnUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#isBasedOnUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isFamilyFriendly"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#isFamilyFriendlyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#isPartOfScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#keywordsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#learningResourceTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#licenseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#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.imageObject#mainEntityOfPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#materialScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#materialExtentScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#mentionsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#nameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#offersList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("pattern"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#patternScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#patternList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("playerType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#playerTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#playerTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("position"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#positionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#publishingPrinciplesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#recordedAtList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("regionsAllowed"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#regionsAllowedList")
                                ],
                                ..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.imageObject#releasedEventList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("representativeOfPage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#representativeOfPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#representativeOfPageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("requiresSubscription"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MediaSubscription#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#requiresSubscriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#requiresSubscriptionList")
                                ],
                                ..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.imageObject#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.imageObject#reviewsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sameAs"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sameAsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sameAsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("schemaVersion"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#schemaVersionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#schemaVersionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sdDatePublished"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sdDatePublishedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#sdLicenseScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#sdPublisherList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sha256"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sha256Scalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sha256List")
                                ],
                                ..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.imageObject#sizeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#sponsorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("startTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#startTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#startTimeList")
                                ],
                                ..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.imageObject#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.imageObject#teachesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#teachesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("temporal"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#temporalScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#temporalList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("temporalCoverage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#temporalCoverageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#temporalCoverageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("text"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#textScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#thumbnailList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("thumbnailUrl"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#thumbnailUrlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#thumbnailUrlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("timeRequired"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#timeRequiredScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#timeRequiredList")
                                ],
                                ..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.imageObject#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.imageObject#translatorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("typicalAgeRange"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#typicalAgeRangeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#typicalAgeRangeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("uploadDate"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#uploadDateScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#uploadDateList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("url"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#urlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#usageInfoScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#usageInfoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("version"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#versionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#videoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("width"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Distance#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#widthScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#widthList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("wordCount"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#wordCountScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#workTranslationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("main"),
                LexUserType::Record(LexRecord {
                    key: Some(CowStr::new_static("tid")),
                    record: LexRecordRecord::Object(LexObject {
                        description: Some(CowStr::new_static("An image file.")),
                        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.imageObject#aboutList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("abstract"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#abstractScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#abstractList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessMode"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessModeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#accessModeSufficientList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilityAPI"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityAPIScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityAPIList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilityControl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityControlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityControlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilityFeature"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityFeatureScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityFeatureList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilityHazard"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityHazardScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilityHazardList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("accessibilitySummary"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#accessibilitySummaryScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#acquireLicensePageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#acquireLicensePageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("additionalType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#additionalTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#aggregateRatingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alternateName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#alternateNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#alternateNameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alternativeHeadline"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#alternativeHeadlineScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#archivedAtScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#assessesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#assessesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("associatedArticle"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.NewsArticle#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#associatedArticleList")
                                    ],
                                    ..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.imageObject#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.imageObject#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.imageObject#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.imageObject#authorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("award"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#awardScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#awardList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("awards"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#awardsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#awardsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("bitrate"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#bitrateScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#bitrateList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("caption"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MediaObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#captionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#captionList")
                                    ],
                                    ..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.imageObject#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.imageObject#citationScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#commentList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("commentCount"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#commentCountScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#commentCountList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("conditionsOfAccess"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#conditionsOfAccessScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#contentRatingScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentRatingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contentReferenceTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentReferenceTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentReferenceTimeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contentSize"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentSizeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentSizeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contentUrl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentUrlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#contentUrlList")
                                    ],
                                    ..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.imageObject#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.imageObject#copyrightHolderList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("copyrightNotice"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#copyrightNoticeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#copyrightNoticeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("copyrightYear"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#copyrightYearScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#correctionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#creativeWorkStatusScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#creatorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("creditText"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#creditTextScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#creditTextList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("dateCreated"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#dateCreatedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#dateCreatedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("dateModified"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#dateModifiedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#dateModifiedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("datePublished"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#datePublishedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#descriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#digitalSourceTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#digitalSourceTypeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("disambiguatingDescription"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#disambiguatingDescriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#disambiguatingDescriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("discussionUrl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#discussionUrlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#durationScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#durationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("editEIDR"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#editEIDRScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#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.imageObject#educationalLevelScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#educationalUseScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#educationalUseList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("embedUrl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#embedUrlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#embedUrlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("embeddedTextCaption"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#embeddedTextCaptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#embeddedTextCaptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("encodesCreativeWork"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#encodesCreativeWorkList")
                                    ],
                                    ..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.imageObject#encodingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("encodingFormat"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#encodingFormatScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#encodingsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("endTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#endTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#endTimeList")
                                    ],
                                    ..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.imageObject#exampleOfWorkList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("exifData"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.PropertyValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#exifDataScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#exifDataList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("expires"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#expiresScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#expiresList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("fileFormat"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#fileFormatScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#fundingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("genre"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#genreScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#hasPartList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("headline"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#headlineScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#headlineList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("height"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Distance#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#heightScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#heightList")
                                    ],
                                    ..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.imageObject#identifierScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#imageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#inLanguageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#inLanguageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("ineligibleRegion"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeoShape#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#ineligibleRegionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#ineligibleRegionList")
                                    ],
                                    ..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.imageObject#interactionStatisticList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("interactivityType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#interactivityTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#interpretedAsClaimList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isAccessibleForFree"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#isAccessibleForFreeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#isBasedOnScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#isBasedOnUrlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#isBasedOnUrlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isFamilyFriendly"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#isFamilyFriendlyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#isPartOfScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#keywordsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#learningResourceTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#licenseScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#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.imageObject#mainEntityOfPageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#materialScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#materialExtentScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#mentionsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("name"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#nameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#offersList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("pattern"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#patternScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#patternList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("playerType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#playerTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#playerTypeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("position"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#positionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#publishingPrinciplesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#recordedAtList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("regionsAllowed"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#regionsAllowedList")
                                    ],
                                    ..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.imageObject#releasedEventList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("representativeOfPage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#representativeOfPageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#representativeOfPageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("requiresSubscription"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MediaSubscription#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#requiresSubscriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#requiresSubscriptionList")
                                    ],
                                    ..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.imageObject#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.imageObject#reviewsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sameAs"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sameAsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sameAsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("schemaVersion"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#schemaVersionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#schemaVersionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sdDatePublished"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sdDatePublishedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#sdLicenseScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#sdPublisherList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sha256"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sha256Scalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#sha256List")
                                    ],
                                    ..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.imageObject#sizeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#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.imageObject#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.imageObject#sponsorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("startTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#startTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#startTimeList")
                                    ],
                                    ..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.imageObject#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.imageObject#teachesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#teachesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("temporal"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#temporalScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#temporalList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("temporalCoverage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#temporalCoverageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#temporalCoverageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("text"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#textScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#thumbnailList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("thumbnailUrl"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#thumbnailUrlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#thumbnailUrlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("timeRequired"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#timeRequiredScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#timeRequiredList")
                                    ],
                                    ..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.imageObject#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.imageObject#translatorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("typicalAgeRange"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#typicalAgeRangeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#typicalAgeRangeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("uploadDate"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#uploadDateScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#uploadDateList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("url"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#urlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#usageInfoScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#usageInfoList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("version"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#versionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#videoList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("width"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Distance#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#widthScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#widthList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("wordCount"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#wordCountScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.imageObject#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.imageObject#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.imageObject#workTranslationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map
                        },
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}

pub mod image_object_state {

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

/// Builder for constructing an instance of this type
pub struct ImageObjectBuilder<'a, S: image_object_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<ImageObjectAbout<'a>>,
        Option<ImageObjectAbstract<'a>>,
        Option<ImageObjectAccessMode<'a>>,
        Option<ImageObjectAccessModeSufficient<'a>>,
        Option<ImageObjectAccessibilityApi<'a>>,
        Option<ImageObjectAccessibilityControl<'a>>,
        Option<ImageObjectAccessibilityFeature<'a>>,
        Option<ImageObjectAccessibilityHazard<'a>>,
        Option<ImageObjectAccessibilitySummary<'a>>,
        Option<ImageObjectAccountablePerson<'a>>,
        Option<ImageObjectAcquireLicensePage<'a>>,
        Option<ImageObjectAdditionalType<'a>>,
        Option<ImageObjectAggregateRating<'a>>,
        Option<ImageObjectAlternateName<'a>>,
        Option<ImageObjectAlternativeHeadline<'a>>,
        Option<ImageObjectArchivedAt<'a>>,
        Option<ImageObjectAssesses<'a>>,
        Option<ImageObjectAssociatedArticle<'a>>,
        Option<ImageObjectAssociatedMedia<'a>>,
        Option<ImageObjectAudience<'a>>,
        Option<ImageObjectAudio<'a>>,
        Option<ImageObjectAuthor<'a>>,
        Option<ImageObjectAward<'a>>,
        Option<ImageObjectAwards<'a>>,
        Option<ImageObjectBitrate<'a>>,
        Option<ImageObjectCaption<'a>>,
        Option<ImageObjectCharacter<'a>>,
        Option<ImageObjectCitation<'a>>,
        Option<ImageObjectComment<'a>>,
        Option<ImageObjectCommentCount<'a>>,
        Option<ImageObjectConditionsOfAccess<'a>>,
        Option<ImageObjectContentLocation<'a>>,
        Option<ImageObjectContentRating<'a>>,
        Option<ImageObjectContentReferenceTime<'a>>,
        Option<ImageObjectContentSize<'a>>,
        Option<ImageObjectContentUrl<'a>>,
        Option<ImageObjectContributor<'a>>,
        Option<ImageObjectCopyrightHolder<'a>>,
        Option<ImageObjectCopyrightNotice<'a>>,
        Option<ImageObjectCopyrightYear<'a>>,
        Option<ImageObjectCorrection<'a>>,
        Option<ImageObjectCountryOfOrigin<'a>>,
        Option<ImageObjectCreativeWorkStatus<'a>>,
        Option<ImageObjectCreator<'a>>,
        Option<ImageObjectCreditText<'a>>,
        Option<ImageObjectDateCreated<'a>>,
        Option<ImageObjectDateModified<'a>>,
        Option<ImageObjectDatePublished<'a>>,
        Option<ImageObjectDescription<'a>>,
        Option<ImageObjectDigitalSourceType<'a>>,
        Option<ImageObjectDisambiguatingDescription<'a>>,
        Option<ImageObjectDiscussionUrl<'a>>,
        Option<ImageObjectDuration<'a>>,
        Option<ImageObjectEditEidr<'a>>,
        Option<ImageObjectEditor<'a>>,
        Option<ImageObjectEducationalAlignment<'a>>,
        Option<ImageObjectEducationalLevel<'a>>,
        Option<ImageObjectEducationalUse<'a>>,
        Option<ImageObjectEmbedUrl<'a>>,
        Option<ImageObjectEmbeddedTextCaption<'a>>,
        Option<ImageObjectEncodesCreativeWork<'a>>,
        Option<ImageObjectEncoding<'a>>,
        Option<ImageObjectEncodingFormat<'a>>,
        Option<ImageObjectEncodings<'a>>,
        Option<ImageObjectEndTime<'a>>,
        Option<ImageObjectExampleOfWork<'a>>,
        Option<ImageObjectExifData<'a>>,
        Option<ImageObjectExpires<'a>>,
        Option<ImageObjectFileFormat<'a>>,
        Option<ImageObjectFunder<'a>>,
        Option<ImageObjectFunding<'a>>,
        Option<ImageObjectGenre<'a>>,
        Option<ImageObjectHasPart<'a>>,
        Option<ImageObjectHeadline<'a>>,
        Option<ImageObjectHeight<'a>>,
        Option<ImageObjectIdentifier<'a>>,
        Option<ImageObjectImage<'a>>,
        Option<ImageObjectInLanguage<'a>>,
        Option<ImageObjectIneligibleRegion<'a>>,
        Option<ImageObjectInteractionStatistic<'a>>,
        Option<ImageObjectInteractivityType<'a>>,
        Option<ImageObjectInterpretedAsClaim<'a>>,
        Option<ImageObjectIsAccessibleForFree<'a>>,
        Option<ImageObjectIsBasedOn<'a>>,
        Option<ImageObjectIsBasedOnUrl<'a>>,
        Option<ImageObjectIsFamilyFriendly<'a>>,
        Option<ImageObjectIsPartOf<'a>>,
        Option<ImageObjectKeywords<'a>>,
        Option<ImageObjectLearningResourceType<'a>>,
        Option<ImageObjectLicense<'a>>,
        Option<ImageObjectLocationCreated<'a>>,
        Option<ImageObjectMainEntity<'a>>,
        Option<ImageObjectMainEntityOfPage<'a>>,
        Option<ImageObjectMaintainer<'a>>,
        Option<ImageObjectMaterial<'a>>,
        Option<ImageObjectMaterialExtent<'a>>,
        Option<ImageObjectMentions<'a>>,
        Option<ImageObjectName<'a>>,
        Option<ImageObjectOffers<'a>>,
        Option<ImageObjectPattern<'a>>,
        Option<ImageObjectPlayerType<'a>>,
        Option<ImageObjectPosition<'a>>,
        Option<ImageObjectPotentialAction<'a>>,
        Option<ImageObjectProducer<'a>>,
        Option<ImageObjectProductionCompany<'a>>,
        Option<ImageObjectProvider<'a>>,
        Option<ImageObjectPublication<'a>>,
        Option<ImageObjectPublisher<'a>>,
        Option<ImageObjectPublisherImprint<'a>>,
        Option<ImageObjectPublishingPrinciples<'a>>,
        Option<ImageObjectRecordedAt<'a>>,
        Option<ImageObjectRegionsAllowed<'a>>,
        Option<ImageObjectReleasedEvent<'a>>,
        Option<ImageObjectRepresentativeOfPage<'a>>,
        Option<ImageObjectRequiresSubscription<'a>>,
        Option<ImageObjectReview<'a>>,
        Option<ImageObjectReviews<'a>>,
        Option<ImageObjectSameAs<'a>>,
        Option<ImageObjectSchemaVersion<'a>>,
        Option<ImageObjectSdDatePublished<'a>>,
        Option<ImageObjectSdLicense<'a>>,
        Option<ImageObjectSdPublisher<'a>>,
        Option<ImageObjectSha256<'a>>,
        Option<ImageObjectSize<'a>>,
        Option<ImageObjectSourceOrganization<'a>>,
        Option<ImageObjectSpatial<'a>>,
        Option<ImageObjectSpatialCoverage<'a>>,
        Option<ImageObjectSponsor<'a>>,
        Option<ImageObjectStartTime<'a>>,
        Option<ImageObjectSubjectOf<'a>>,
        Option<ImageObjectTeaches<'a>>,
        Option<ImageObjectTemporal<'a>>,
        Option<ImageObjectTemporalCoverage<'a>>,
        Option<ImageObjectText<'a>>,
        Option<ImageObjectThumbnail<'a>>,
        Option<ImageObjectThumbnailUrl<'a>>,
        Option<ImageObjectTimeRequired<'a>>,
        Option<ImageObjectTranslationOfWork<'a>>,
        Option<ImageObjectTranslator<'a>>,
        Option<ImageObjectTypicalAgeRange<'a>>,
        Option<ImageObjectUploadDate<'a>>,
        Option<ImageObjectUrl<'a>>,
        Option<ImageObjectUsageInfo<'a>>,
        Option<ImageObjectVersion<'a>>,
        Option<ImageObjectVideo<'a>>,
        Option<ImageObjectWidth<'a>>,
        Option<ImageObjectWordCount<'a>>,
        Option<ImageObjectWorkExample<'a>>,
        Option<ImageObjectWorkTranslation<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> ImageObject<'a> {
    /// Create a new builder for this type
    pub fn new() -> ImageObjectBuilder<'a, image_object_state::Empty> {
        ImageObjectBuilder::new()
    }
}

impl<'a> ImageObjectBuilder<'a, image_object_state::Empty> {
    /// Create a new builder with all fields unset
    pub fn new() -> Self {
        ImageObjectBuilder {
            _state: PhantomData,
            _fields: (
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
            ),
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `about` field (optional)
    pub fn about(mut self, value: impl Into<Option<ImageObjectAbout<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `about` field to an Option value (optional)
    pub fn maybe_about(mut self, value: Option<ImageObjectAbout<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `abstract` field (optional)
    pub fn r#abstract(
        mut self,
        value: impl Into<Option<ImageObjectAbstract<'a>>>,
    ) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `abstract` field to an Option value (optional)
    pub fn maybe_abstract(mut self, value: Option<ImageObjectAbstract<'a>>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `accessMode` field (optional)
    pub fn access_mode(
        mut self,
        value: impl Into<Option<ImageObjectAccessMode<'a>>>,
    ) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `accessMode` field to an Option value (optional)
    pub fn maybe_access_mode(
        mut self,
        value: Option<ImageObjectAccessMode<'a>>,
    ) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `accessModeSufficient` field (optional)
    pub fn access_mode_sufficient(
        mut self,
        value: impl Into<Option<ImageObjectAccessModeSufficient<'a>>>,
    ) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `accessModeSufficient` field to an Option value (optional)
    pub fn maybe_access_mode_sufficient(
        mut self,
        value: Option<ImageObjectAccessModeSufficient<'a>>,
    ) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `accessibilityAPI` field (optional)
    pub fn accessibility_api(
        mut self,
        value: impl Into<Option<ImageObjectAccessibilityApi<'a>>>,
    ) -> Self {
        self._fields.4 = value.into();
        self
    }
    /// Set the `accessibilityAPI` field to an Option value (optional)
    pub fn maybe_accessibility_api(
        mut self,
        value: Option<ImageObjectAccessibilityApi<'a>>,
    ) -> Self {
        self._fields.4 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `accessibilityControl` field (optional)
    pub fn accessibility_control(
        mut self,
        value: impl Into<Option<ImageObjectAccessibilityControl<'a>>>,
    ) -> Self {
        self._fields.5 = value.into();
        self
    }
    /// Set the `accessibilityControl` field to an Option value (optional)
    pub fn maybe_accessibility_control(
        mut self,
        value: Option<ImageObjectAccessibilityControl<'a>>,
    ) -> Self {
        self._fields.5 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `accessibilityFeature` field (optional)
    pub fn accessibility_feature(
        mut self,
        value: impl Into<Option<ImageObjectAccessibilityFeature<'a>>>,
    ) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `accessibilityFeature` field to an Option value (optional)
    pub fn maybe_accessibility_feature(
        mut self,
        value: Option<ImageObjectAccessibilityFeature<'a>>,
    ) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `accessibilityHazard` field (optional)
    pub fn accessibility_hazard(
        mut self,
        value: impl Into<Option<ImageObjectAccessibilityHazard<'a>>>,
    ) -> Self {
        self._fields.7 = value.into();
        self
    }
    /// Set the `accessibilityHazard` field to an Option value (optional)
    pub fn maybe_accessibility_hazard(
        mut self,
        value: Option<ImageObjectAccessibilityHazard<'a>>,
    ) -> Self {
        self._fields.7 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `accessibilitySummary` field (optional)
    pub fn accessibility_summary(
        mut self,
        value: impl Into<Option<ImageObjectAccessibilitySummary<'a>>>,
    ) -> Self {
        self._fields.8 = value.into();
        self
    }
    /// Set the `accessibilitySummary` field to an Option value (optional)
    pub fn maybe_accessibility_summary(
        mut self,
        value: Option<ImageObjectAccessibilitySummary<'a>>,
    ) -> Self {
        self._fields.8 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `accountablePerson` field (optional)
    pub fn accountable_person(
        mut self,
        value: impl Into<Option<ImageObjectAccountablePerson<'a>>>,
    ) -> Self {
        self._fields.9 = value.into();
        self
    }
    /// Set the `accountablePerson` field to an Option value (optional)
    pub fn maybe_accountable_person(
        mut self,
        value: Option<ImageObjectAccountablePerson<'a>>,
    ) -> Self {
        self._fields.9 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `acquireLicensePage` field (optional)
    pub fn acquire_license_page(
        mut self,
        value: impl Into<Option<ImageObjectAcquireLicensePage<'a>>>,
    ) -> Self {
        self._fields.10 = value.into();
        self
    }
    /// Set the `acquireLicensePage` field to an Option value (optional)
    pub fn maybe_acquire_license_page(
        mut self,
        value: Option<ImageObjectAcquireLicensePage<'a>>,
    ) -> Self {
        self._fields.10 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `additionalType` field (optional)
    pub fn additional_type(
        mut self,
        value: impl Into<Option<ImageObjectAdditionalType<'a>>>,
    ) -> Self {
        self._fields.11 = value.into();
        self
    }
    /// Set the `additionalType` field to an Option value (optional)
    pub fn maybe_additional_type(
        mut self,
        value: Option<ImageObjectAdditionalType<'a>>,
    ) -> Self {
        self._fields.11 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `aggregateRating` field (optional)
    pub fn aggregate_rating(
        mut self,
        value: impl Into<Option<ImageObjectAggregateRating<'a>>>,
    ) -> Self {
        self._fields.12 = value.into();
        self
    }
    /// Set the `aggregateRating` field to an Option value (optional)
    pub fn maybe_aggregate_rating(
        mut self,
        value: Option<ImageObjectAggregateRating<'a>>,
    ) -> Self {
        self._fields.12 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `alternateName` field (optional)
    pub fn alternate_name(
        mut self,
        value: impl Into<Option<ImageObjectAlternateName<'a>>>,
    ) -> Self {
        self._fields.13 = value.into();
        self
    }
    /// Set the `alternateName` field to an Option value (optional)
    pub fn maybe_alternate_name(
        mut self,
        value: Option<ImageObjectAlternateName<'a>>,
    ) -> Self {
        self._fields.13 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `alternativeHeadline` field (optional)
    pub fn alternative_headline(
        mut self,
        value: impl Into<Option<ImageObjectAlternativeHeadline<'a>>>,
    ) -> Self {
        self._fields.14 = value.into();
        self
    }
    /// Set the `alternativeHeadline` field to an Option value (optional)
    pub fn maybe_alternative_headline(
        mut self,
        value: Option<ImageObjectAlternativeHeadline<'a>>,
    ) -> Self {
        self._fields.14 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `archivedAt` field (optional)
    pub fn archived_at(
        mut self,
        value: impl Into<Option<ImageObjectArchivedAt<'a>>>,
    ) -> Self {
        self._fields.15 = value.into();
        self
    }
    /// Set the `archivedAt` field to an Option value (optional)
    pub fn maybe_archived_at(
        mut self,
        value: Option<ImageObjectArchivedAt<'a>>,
    ) -> Self {
        self._fields.15 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `assesses` field (optional)
    pub fn assesses(
        mut self,
        value: impl Into<Option<ImageObjectAssesses<'a>>>,
    ) -> Self {
        self._fields.16 = value.into();
        self
    }
    /// Set the `assesses` field to an Option value (optional)
    pub fn maybe_assesses(mut self, value: Option<ImageObjectAssesses<'a>>) -> Self {
        self._fields.16 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `associatedArticle` field (optional)
    pub fn associated_article(
        mut self,
        value: impl Into<Option<ImageObjectAssociatedArticle<'a>>>,
    ) -> Self {
        self._fields.17 = value.into();
        self
    }
    /// Set the `associatedArticle` field to an Option value (optional)
    pub fn maybe_associated_article(
        mut self,
        value: Option<ImageObjectAssociatedArticle<'a>>,
    ) -> Self {
        self._fields.17 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `associatedMedia` field (optional)
    pub fn associated_media(
        mut self,
        value: impl Into<Option<ImageObjectAssociatedMedia<'a>>>,
    ) -> Self {
        self._fields.18 = value.into();
        self
    }
    /// Set the `associatedMedia` field to an Option value (optional)
    pub fn maybe_associated_media(
        mut self,
        value: Option<ImageObjectAssociatedMedia<'a>>,
    ) -> Self {
        self._fields.18 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `audience` field (optional)
    pub fn audience(
        mut self,
        value: impl Into<Option<ImageObjectAudience<'a>>>,
    ) -> Self {
        self._fields.19 = value.into();
        self
    }
    /// Set the `audience` field to an Option value (optional)
    pub fn maybe_audience(mut self, value: Option<ImageObjectAudience<'a>>) -> Self {
        self._fields.19 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `audio` field (optional)
    pub fn audio(mut self, value: impl Into<Option<ImageObjectAudio<'a>>>) -> Self {
        self._fields.20 = value.into();
        self
    }
    /// Set the `audio` field to an Option value (optional)
    pub fn maybe_audio(mut self, value: Option<ImageObjectAudio<'a>>) -> Self {
        self._fields.20 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `author` field (optional)
    pub fn author(mut self, value: impl Into<Option<ImageObjectAuthor<'a>>>) -> Self {
        self._fields.21 = value.into();
        self
    }
    /// Set the `author` field to an Option value (optional)
    pub fn maybe_author(mut self, value: Option<ImageObjectAuthor<'a>>) -> Self {
        self._fields.21 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `award` field (optional)
    pub fn award(mut self, value: impl Into<Option<ImageObjectAward<'a>>>) -> Self {
        self._fields.22 = value.into();
        self
    }
    /// Set the `award` field to an Option value (optional)
    pub fn maybe_award(mut self, value: Option<ImageObjectAward<'a>>) -> Self {
        self._fields.22 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `awards` field (optional)
    pub fn awards(mut self, value: impl Into<Option<ImageObjectAwards<'a>>>) -> Self {
        self._fields.23 = value.into();
        self
    }
    /// Set the `awards` field to an Option value (optional)
    pub fn maybe_awards(mut self, value: Option<ImageObjectAwards<'a>>) -> Self {
        self._fields.23 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `bitrate` field (optional)
    pub fn bitrate(mut self, value: impl Into<Option<ImageObjectBitrate<'a>>>) -> Self {
        self._fields.24 = value.into();
        self
    }
    /// Set the `bitrate` field to an Option value (optional)
    pub fn maybe_bitrate(mut self, value: Option<ImageObjectBitrate<'a>>) -> Self {
        self._fields.24 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `caption` field (optional)
    pub fn caption(mut self, value: impl Into<Option<ImageObjectCaption<'a>>>) -> Self {
        self._fields.25 = value.into();
        self
    }
    /// Set the `caption` field to an Option value (optional)
    pub fn maybe_caption(mut self, value: Option<ImageObjectCaption<'a>>) -> Self {
        self._fields.25 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `character` field (optional)
    pub fn character(
        mut self,
        value: impl Into<Option<ImageObjectCharacter<'a>>>,
    ) -> Self {
        self._fields.26 = value.into();
        self
    }
    /// Set the `character` field to an Option value (optional)
    pub fn maybe_character(mut self, value: Option<ImageObjectCharacter<'a>>) -> Self {
        self._fields.26 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `citation` field (optional)
    pub fn citation(
        mut self,
        value: impl Into<Option<ImageObjectCitation<'a>>>,
    ) -> Self {
        self._fields.27 = value.into();
        self
    }
    /// Set the `citation` field to an Option value (optional)
    pub fn maybe_citation(mut self, value: Option<ImageObjectCitation<'a>>) -> Self {
        self._fields.27 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `comment` field (optional)
    pub fn comment(mut self, value: impl Into<Option<ImageObjectComment<'a>>>) -> Self {
        self._fields.28 = value.into();
        self
    }
    /// Set the `comment` field to an Option value (optional)
    pub fn maybe_comment(mut self, value: Option<ImageObjectComment<'a>>) -> Self {
        self._fields.28 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `commentCount` field (optional)
    pub fn comment_count(
        mut self,
        value: impl Into<Option<ImageObjectCommentCount<'a>>>,
    ) -> Self {
        self._fields.29 = value.into();
        self
    }
    /// Set the `commentCount` field to an Option value (optional)
    pub fn maybe_comment_count(
        mut self,
        value: Option<ImageObjectCommentCount<'a>>,
    ) -> Self {
        self._fields.29 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `conditionsOfAccess` field (optional)
    pub fn conditions_of_access(
        mut self,
        value: impl Into<Option<ImageObjectConditionsOfAccess<'a>>>,
    ) -> Self {
        self._fields.30 = value.into();
        self
    }
    /// Set the `conditionsOfAccess` field to an Option value (optional)
    pub fn maybe_conditions_of_access(
        mut self,
        value: Option<ImageObjectConditionsOfAccess<'a>>,
    ) -> Self {
        self._fields.30 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `contentLocation` field (optional)
    pub fn content_location(
        mut self,
        value: impl Into<Option<ImageObjectContentLocation<'a>>>,
    ) -> Self {
        self._fields.31 = value.into();
        self
    }
    /// Set the `contentLocation` field to an Option value (optional)
    pub fn maybe_content_location(
        mut self,
        value: Option<ImageObjectContentLocation<'a>>,
    ) -> Self {
        self._fields.31 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `contentRating` field (optional)
    pub fn content_rating(
        mut self,
        value: impl Into<Option<ImageObjectContentRating<'a>>>,
    ) -> Self {
        self._fields.32 = value.into();
        self
    }
    /// Set the `contentRating` field to an Option value (optional)
    pub fn maybe_content_rating(
        mut self,
        value: Option<ImageObjectContentRating<'a>>,
    ) -> Self {
        self._fields.32 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `contentReferenceTime` field (optional)
    pub fn content_reference_time(
        mut self,
        value: impl Into<Option<ImageObjectContentReferenceTime<'a>>>,
    ) -> Self {
        self._fields.33 = value.into();
        self
    }
    /// Set the `contentReferenceTime` field to an Option value (optional)
    pub fn maybe_content_reference_time(
        mut self,
        value: Option<ImageObjectContentReferenceTime<'a>>,
    ) -> Self {
        self._fields.33 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `contentSize` field (optional)
    pub fn content_size(
        mut self,
        value: impl Into<Option<ImageObjectContentSize<'a>>>,
    ) -> Self {
        self._fields.34 = value.into();
        self
    }
    /// Set the `contentSize` field to an Option value (optional)
    pub fn maybe_content_size(
        mut self,
        value: Option<ImageObjectContentSize<'a>>,
    ) -> Self {
        self._fields.34 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `contentUrl` field (optional)
    pub fn content_url(
        mut self,
        value: impl Into<Option<ImageObjectContentUrl<'a>>>,
    ) -> Self {
        self._fields.35 = value.into();
        self
    }
    /// Set the `contentUrl` field to an Option value (optional)
    pub fn maybe_content_url(
        mut self,
        value: Option<ImageObjectContentUrl<'a>>,
    ) -> Self {
        self._fields.35 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `contributor` field (optional)
    pub fn contributor(
        mut self,
        value: impl Into<Option<ImageObjectContributor<'a>>>,
    ) -> Self {
        self._fields.36 = value.into();
        self
    }
    /// Set the `contributor` field to an Option value (optional)
    pub fn maybe_contributor(
        mut self,
        value: Option<ImageObjectContributor<'a>>,
    ) -> Self {
        self._fields.36 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `copyrightHolder` field (optional)
    pub fn copyright_holder(
        mut self,
        value: impl Into<Option<ImageObjectCopyrightHolder<'a>>>,
    ) -> Self {
        self._fields.37 = value.into();
        self
    }
    /// Set the `copyrightHolder` field to an Option value (optional)
    pub fn maybe_copyright_holder(
        mut self,
        value: Option<ImageObjectCopyrightHolder<'a>>,
    ) -> Self {
        self._fields.37 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `copyrightNotice` field (optional)
    pub fn copyright_notice(
        mut self,
        value: impl Into<Option<ImageObjectCopyrightNotice<'a>>>,
    ) -> Self {
        self._fields.38 = value.into();
        self
    }
    /// Set the `copyrightNotice` field to an Option value (optional)
    pub fn maybe_copyright_notice(
        mut self,
        value: Option<ImageObjectCopyrightNotice<'a>>,
    ) -> Self {
        self._fields.38 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `copyrightYear` field (optional)
    pub fn copyright_year(
        mut self,
        value: impl Into<Option<ImageObjectCopyrightYear<'a>>>,
    ) -> Self {
        self._fields.39 = value.into();
        self
    }
    /// Set the `copyrightYear` field to an Option value (optional)
    pub fn maybe_copyright_year(
        mut self,
        value: Option<ImageObjectCopyrightYear<'a>>,
    ) -> Self {
        self._fields.39 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `correction` field (optional)
    pub fn correction(
        mut self,
        value: impl Into<Option<ImageObjectCorrection<'a>>>,
    ) -> Self {
        self._fields.40 = value.into();
        self
    }
    /// Set the `correction` field to an Option value (optional)
    pub fn maybe_correction(mut self, value: Option<ImageObjectCorrection<'a>>) -> Self {
        self._fields.40 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `countryOfOrigin` field (optional)
    pub fn country_of_origin(
        mut self,
        value: impl Into<Option<ImageObjectCountryOfOrigin<'a>>>,
    ) -> Self {
        self._fields.41 = value.into();
        self
    }
    /// Set the `countryOfOrigin` field to an Option value (optional)
    pub fn maybe_country_of_origin(
        mut self,
        value: Option<ImageObjectCountryOfOrigin<'a>>,
    ) -> Self {
        self._fields.41 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `creativeWorkStatus` field (optional)
    pub fn creative_work_status(
        mut self,
        value: impl Into<Option<ImageObjectCreativeWorkStatus<'a>>>,
    ) -> Self {
        self._fields.42 = value.into();
        self
    }
    /// Set the `creativeWorkStatus` field to an Option value (optional)
    pub fn maybe_creative_work_status(
        mut self,
        value: Option<ImageObjectCreativeWorkStatus<'a>>,
    ) -> Self {
        self._fields.42 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `creator` field (optional)
    pub fn creator(mut self, value: impl Into<Option<ImageObjectCreator<'a>>>) -> Self {
        self._fields.43 = value.into();
        self
    }
    /// Set the `creator` field to an Option value (optional)
    pub fn maybe_creator(mut self, value: Option<ImageObjectCreator<'a>>) -> Self {
        self._fields.43 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `creditText` field (optional)
    pub fn credit_text(
        mut self,
        value: impl Into<Option<ImageObjectCreditText<'a>>>,
    ) -> Self {
        self._fields.44 = value.into();
        self
    }
    /// Set the `creditText` field to an Option value (optional)
    pub fn maybe_credit_text(
        mut self,
        value: Option<ImageObjectCreditText<'a>>,
    ) -> Self {
        self._fields.44 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `dateCreated` field (optional)
    pub fn date_created(
        mut self,
        value: impl Into<Option<ImageObjectDateCreated<'a>>>,
    ) -> Self {
        self._fields.45 = value.into();
        self
    }
    /// Set the `dateCreated` field to an Option value (optional)
    pub fn maybe_date_created(
        mut self,
        value: Option<ImageObjectDateCreated<'a>>,
    ) -> Self {
        self._fields.45 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `dateModified` field (optional)
    pub fn date_modified(
        mut self,
        value: impl Into<Option<ImageObjectDateModified<'a>>>,
    ) -> Self {
        self._fields.46 = value.into();
        self
    }
    /// Set the `dateModified` field to an Option value (optional)
    pub fn maybe_date_modified(
        mut self,
        value: Option<ImageObjectDateModified<'a>>,
    ) -> Self {
        self._fields.46 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `datePublished` field (optional)
    pub fn date_published(
        mut self,
        value: impl Into<Option<ImageObjectDatePublished<'a>>>,
    ) -> Self {
        self._fields.47 = value.into();
        self
    }
    /// Set the `datePublished` field to an Option value (optional)
    pub fn maybe_date_published(
        mut self,
        value: Option<ImageObjectDatePublished<'a>>,
    ) -> Self {
        self._fields.47 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `description` field (optional)
    pub fn description(
        mut self,
        value: impl Into<Option<ImageObjectDescription<'a>>>,
    ) -> Self {
        self._fields.48 = value.into();
        self
    }
    /// Set the `description` field to an Option value (optional)
    pub fn maybe_description(
        mut self,
        value: Option<ImageObjectDescription<'a>>,
    ) -> Self {
        self._fields.48 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `digitalSourceType` field (optional)
    pub fn digital_source_type(
        mut self,
        value: impl Into<Option<ImageObjectDigitalSourceType<'a>>>,
    ) -> Self {
        self._fields.49 = value.into();
        self
    }
    /// Set the `digitalSourceType` field to an Option value (optional)
    pub fn maybe_digital_source_type(
        mut self,
        value: Option<ImageObjectDigitalSourceType<'a>>,
    ) -> Self {
        self._fields.49 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `disambiguatingDescription` field (optional)
    pub fn disambiguating_description(
        mut self,
        value: impl Into<Option<ImageObjectDisambiguatingDescription<'a>>>,
    ) -> Self {
        self._fields.50 = value.into();
        self
    }
    /// Set the `disambiguatingDescription` field to an Option value (optional)
    pub fn maybe_disambiguating_description(
        mut self,
        value: Option<ImageObjectDisambiguatingDescription<'a>>,
    ) -> Self {
        self._fields.50 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `discussionUrl` field (optional)
    pub fn discussion_url(
        mut self,
        value: impl Into<Option<ImageObjectDiscussionUrl<'a>>>,
    ) -> Self {
        self._fields.51 = value.into();
        self
    }
    /// Set the `discussionUrl` field to an Option value (optional)
    pub fn maybe_discussion_url(
        mut self,
        value: Option<ImageObjectDiscussionUrl<'a>>,
    ) -> Self {
        self._fields.51 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `duration` field (optional)
    pub fn duration(
        mut self,
        value: impl Into<Option<ImageObjectDuration<'a>>>,
    ) -> Self {
        self._fields.52 = value.into();
        self
    }
    /// Set the `duration` field to an Option value (optional)
    pub fn maybe_duration(mut self, value: Option<ImageObjectDuration<'a>>) -> Self {
        self._fields.52 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `editEIDR` field (optional)
    pub fn edit_eidr(
        mut self,
        value: impl Into<Option<ImageObjectEditEidr<'a>>>,
    ) -> Self {
        self._fields.53 = value.into();
        self
    }
    /// Set the `editEIDR` field to an Option value (optional)
    pub fn maybe_edit_eidr(mut self, value: Option<ImageObjectEditEidr<'a>>) -> Self {
        self._fields.53 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `editor` field (optional)
    pub fn editor(mut self, value: impl Into<Option<ImageObjectEditor<'a>>>) -> Self {
        self._fields.54 = value.into();
        self
    }
    /// Set the `editor` field to an Option value (optional)
    pub fn maybe_editor(mut self, value: Option<ImageObjectEditor<'a>>) -> Self {
        self._fields.54 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `educationalAlignment` field (optional)
    pub fn educational_alignment(
        mut self,
        value: impl Into<Option<ImageObjectEducationalAlignment<'a>>>,
    ) -> Self {
        self._fields.55 = value.into();
        self
    }
    /// Set the `educationalAlignment` field to an Option value (optional)
    pub fn maybe_educational_alignment(
        mut self,
        value: Option<ImageObjectEducationalAlignment<'a>>,
    ) -> Self {
        self._fields.55 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `educationalLevel` field (optional)
    pub fn educational_level(
        mut self,
        value: impl Into<Option<ImageObjectEducationalLevel<'a>>>,
    ) -> Self {
        self._fields.56 = value.into();
        self
    }
    /// Set the `educationalLevel` field to an Option value (optional)
    pub fn maybe_educational_level(
        mut self,
        value: Option<ImageObjectEducationalLevel<'a>>,
    ) -> Self {
        self._fields.56 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `educationalUse` field (optional)
    pub fn educational_use(
        mut self,
        value: impl Into<Option<ImageObjectEducationalUse<'a>>>,
    ) -> Self {
        self._fields.57 = value.into();
        self
    }
    /// Set the `educationalUse` field to an Option value (optional)
    pub fn maybe_educational_use(
        mut self,
        value: Option<ImageObjectEducationalUse<'a>>,
    ) -> Self {
        self._fields.57 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `embedUrl` field (optional)
    pub fn embed_url(
        mut self,
        value: impl Into<Option<ImageObjectEmbedUrl<'a>>>,
    ) -> Self {
        self._fields.58 = value.into();
        self
    }
    /// Set the `embedUrl` field to an Option value (optional)
    pub fn maybe_embed_url(mut self, value: Option<ImageObjectEmbedUrl<'a>>) -> Self {
        self._fields.58 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `embeddedTextCaption` field (optional)
    pub fn embedded_text_caption(
        mut self,
        value: impl Into<Option<ImageObjectEmbeddedTextCaption<'a>>>,
    ) -> Self {
        self._fields.59 = value.into();
        self
    }
    /// Set the `embeddedTextCaption` field to an Option value (optional)
    pub fn maybe_embedded_text_caption(
        mut self,
        value: Option<ImageObjectEmbeddedTextCaption<'a>>,
    ) -> Self {
        self._fields.59 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `encodesCreativeWork` field (optional)
    pub fn encodes_creative_work(
        mut self,
        value: impl Into<Option<ImageObjectEncodesCreativeWork<'a>>>,
    ) -> Self {
        self._fields.60 = value.into();
        self
    }
    /// Set the `encodesCreativeWork` field to an Option value (optional)
    pub fn maybe_encodes_creative_work(
        mut self,
        value: Option<ImageObjectEncodesCreativeWork<'a>>,
    ) -> Self {
        self._fields.60 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `encoding` field (optional)
    pub fn encoding(
        mut self,
        value: impl Into<Option<ImageObjectEncoding<'a>>>,
    ) -> Self {
        self._fields.61 = value.into();
        self
    }
    /// Set the `encoding` field to an Option value (optional)
    pub fn maybe_encoding(mut self, value: Option<ImageObjectEncoding<'a>>) -> Self {
        self._fields.61 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `encodingFormat` field (optional)
    pub fn encoding_format(
        mut self,
        value: impl Into<Option<ImageObjectEncodingFormat<'a>>>,
    ) -> Self {
        self._fields.62 = value.into();
        self
    }
    /// Set the `encodingFormat` field to an Option value (optional)
    pub fn maybe_encoding_format(
        mut self,
        value: Option<ImageObjectEncodingFormat<'a>>,
    ) -> Self {
        self._fields.62 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `encodings` field (optional)
    pub fn encodings(
        mut self,
        value: impl Into<Option<ImageObjectEncodings<'a>>>,
    ) -> Self {
        self._fields.63 = value.into();
        self
    }
    /// Set the `encodings` field to an Option value (optional)
    pub fn maybe_encodings(mut self, value: Option<ImageObjectEncodings<'a>>) -> Self {
        self._fields.63 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `endTime` field (optional)
    pub fn end_time(mut self, value: impl Into<Option<ImageObjectEndTime<'a>>>) -> Self {
        self._fields.64 = value.into();
        self
    }
    /// Set the `endTime` field to an Option value (optional)
    pub fn maybe_end_time(mut self, value: Option<ImageObjectEndTime<'a>>) -> Self {
        self._fields.64 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `exampleOfWork` field (optional)
    pub fn example_of_work(
        mut self,
        value: impl Into<Option<ImageObjectExampleOfWork<'a>>>,
    ) -> Self {
        self._fields.65 = value.into();
        self
    }
    /// Set the `exampleOfWork` field to an Option value (optional)
    pub fn maybe_example_of_work(
        mut self,
        value: Option<ImageObjectExampleOfWork<'a>>,
    ) -> Self {
        self._fields.65 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `exifData` field (optional)
    pub fn exif_data(
        mut self,
        value: impl Into<Option<ImageObjectExifData<'a>>>,
    ) -> Self {
        self._fields.66 = value.into();
        self
    }
    /// Set the `exifData` field to an Option value (optional)
    pub fn maybe_exif_data(mut self, value: Option<ImageObjectExifData<'a>>) -> Self {
        self._fields.66 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `expires` field (optional)
    pub fn expires(mut self, value: impl Into<Option<ImageObjectExpires<'a>>>) -> Self {
        self._fields.67 = value.into();
        self
    }
    /// Set the `expires` field to an Option value (optional)
    pub fn maybe_expires(mut self, value: Option<ImageObjectExpires<'a>>) -> Self {
        self._fields.67 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `fileFormat` field (optional)
    pub fn file_format(
        mut self,
        value: impl Into<Option<ImageObjectFileFormat<'a>>>,
    ) -> Self {
        self._fields.68 = value.into();
        self
    }
    /// Set the `fileFormat` field to an Option value (optional)
    pub fn maybe_file_format(
        mut self,
        value: Option<ImageObjectFileFormat<'a>>,
    ) -> Self {
        self._fields.68 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `funder` field (optional)
    pub fn funder(mut self, value: impl Into<Option<ImageObjectFunder<'a>>>) -> Self {
        self._fields.69 = value.into();
        self
    }
    /// Set the `funder` field to an Option value (optional)
    pub fn maybe_funder(mut self, value: Option<ImageObjectFunder<'a>>) -> Self {
        self._fields.69 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `funding` field (optional)
    pub fn funding(mut self, value: impl Into<Option<ImageObjectFunding<'a>>>) -> Self {
        self._fields.70 = value.into();
        self
    }
    /// Set the `funding` field to an Option value (optional)
    pub fn maybe_funding(mut self, value: Option<ImageObjectFunding<'a>>) -> Self {
        self._fields.70 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `genre` field (optional)
    pub fn genre(mut self, value: impl Into<Option<ImageObjectGenre<'a>>>) -> Self {
        self._fields.71 = value.into();
        self
    }
    /// Set the `genre` field to an Option value (optional)
    pub fn maybe_genre(mut self, value: Option<ImageObjectGenre<'a>>) -> Self {
        self._fields.71 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `hasPart` field (optional)
    pub fn has_part(mut self, value: impl Into<Option<ImageObjectHasPart<'a>>>) -> Self {
        self._fields.72 = value.into();
        self
    }
    /// Set the `hasPart` field to an Option value (optional)
    pub fn maybe_has_part(mut self, value: Option<ImageObjectHasPart<'a>>) -> Self {
        self._fields.72 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `headline` field (optional)
    pub fn headline(
        mut self,
        value: impl Into<Option<ImageObjectHeadline<'a>>>,
    ) -> Self {
        self._fields.73 = value.into();
        self
    }
    /// Set the `headline` field to an Option value (optional)
    pub fn maybe_headline(mut self, value: Option<ImageObjectHeadline<'a>>) -> Self {
        self._fields.73 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `height` field (optional)
    pub fn height(mut self, value: impl Into<Option<ImageObjectHeight<'a>>>) -> Self {
        self._fields.74 = value.into();
        self
    }
    /// Set the `height` field to an Option value (optional)
    pub fn maybe_height(mut self, value: Option<ImageObjectHeight<'a>>) -> Self {
        self._fields.74 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `identifier` field (optional)
    pub fn identifier(
        mut self,
        value: impl Into<Option<ImageObjectIdentifier<'a>>>,
    ) -> Self {
        self._fields.75 = value.into();
        self
    }
    /// Set the `identifier` field to an Option value (optional)
    pub fn maybe_identifier(mut self, value: Option<ImageObjectIdentifier<'a>>) -> Self {
        self._fields.75 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `image` field (optional)
    pub fn image(mut self, value: impl Into<Option<ImageObjectImage<'a>>>) -> Self {
        self._fields.76 = value.into();
        self
    }
    /// Set the `image` field to an Option value (optional)
    pub fn maybe_image(mut self, value: Option<ImageObjectImage<'a>>) -> Self {
        self._fields.76 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `inLanguage` field (optional)
    pub fn in_language(
        mut self,
        value: impl Into<Option<ImageObjectInLanguage<'a>>>,
    ) -> Self {
        self._fields.77 = value.into();
        self
    }
    /// Set the `inLanguage` field to an Option value (optional)
    pub fn maybe_in_language(
        mut self,
        value: Option<ImageObjectInLanguage<'a>>,
    ) -> Self {
        self._fields.77 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `ineligibleRegion` field (optional)
    pub fn ineligible_region(
        mut self,
        value: impl Into<Option<ImageObjectIneligibleRegion<'a>>>,
    ) -> Self {
        self._fields.78 = value.into();
        self
    }
    /// Set the `ineligibleRegion` field to an Option value (optional)
    pub fn maybe_ineligible_region(
        mut self,
        value: Option<ImageObjectIneligibleRegion<'a>>,
    ) -> Self {
        self._fields.78 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `interactionStatistic` field (optional)
    pub fn interaction_statistic(
        mut self,
        value: impl Into<Option<ImageObjectInteractionStatistic<'a>>>,
    ) -> Self {
        self._fields.79 = value.into();
        self
    }
    /// Set the `interactionStatistic` field to an Option value (optional)
    pub fn maybe_interaction_statistic(
        mut self,
        value: Option<ImageObjectInteractionStatistic<'a>>,
    ) -> Self {
        self._fields.79 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `interactivityType` field (optional)
    pub fn interactivity_type(
        mut self,
        value: impl Into<Option<ImageObjectInteractivityType<'a>>>,
    ) -> Self {
        self._fields.80 = value.into();
        self
    }
    /// Set the `interactivityType` field to an Option value (optional)
    pub fn maybe_interactivity_type(
        mut self,
        value: Option<ImageObjectInteractivityType<'a>>,
    ) -> Self {
        self._fields.80 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `interpretedAsClaim` field (optional)
    pub fn interpreted_as_claim(
        mut self,
        value: impl Into<Option<ImageObjectInterpretedAsClaim<'a>>>,
    ) -> Self {
        self._fields.81 = value.into();
        self
    }
    /// Set the `interpretedAsClaim` field to an Option value (optional)
    pub fn maybe_interpreted_as_claim(
        mut self,
        value: Option<ImageObjectInterpretedAsClaim<'a>>,
    ) -> Self {
        self._fields.81 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `isAccessibleForFree` field (optional)
    pub fn is_accessible_for_free(
        mut self,
        value: impl Into<Option<ImageObjectIsAccessibleForFree<'a>>>,
    ) -> Self {
        self._fields.82 = value.into();
        self
    }
    /// Set the `isAccessibleForFree` field to an Option value (optional)
    pub fn maybe_is_accessible_for_free(
        mut self,
        value: Option<ImageObjectIsAccessibleForFree<'a>>,
    ) -> Self {
        self._fields.82 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `isBasedOn` field (optional)
    pub fn is_based_on(
        mut self,
        value: impl Into<Option<ImageObjectIsBasedOn<'a>>>,
    ) -> Self {
        self._fields.83 = value.into();
        self
    }
    /// Set the `isBasedOn` field to an Option value (optional)
    pub fn maybe_is_based_on(mut self, value: Option<ImageObjectIsBasedOn<'a>>) -> Self {
        self._fields.83 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `isBasedOnUrl` field (optional)
    pub fn is_based_on_url(
        mut self,
        value: impl Into<Option<ImageObjectIsBasedOnUrl<'a>>>,
    ) -> Self {
        self._fields.84 = value.into();
        self
    }
    /// Set the `isBasedOnUrl` field to an Option value (optional)
    pub fn maybe_is_based_on_url(
        mut self,
        value: Option<ImageObjectIsBasedOnUrl<'a>>,
    ) -> Self {
        self._fields.84 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `isFamilyFriendly` field (optional)
    pub fn is_family_friendly(
        mut self,
        value: impl Into<Option<ImageObjectIsFamilyFriendly<'a>>>,
    ) -> Self {
        self._fields.85 = value.into();
        self
    }
    /// Set the `isFamilyFriendly` field to an Option value (optional)
    pub fn maybe_is_family_friendly(
        mut self,
        value: Option<ImageObjectIsFamilyFriendly<'a>>,
    ) -> Self {
        self._fields.85 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `isPartOf` field (optional)
    pub fn is_part_of(
        mut self,
        value: impl Into<Option<ImageObjectIsPartOf<'a>>>,
    ) -> Self {
        self._fields.86 = value.into();
        self
    }
    /// Set the `isPartOf` field to an Option value (optional)
    pub fn maybe_is_part_of(mut self, value: Option<ImageObjectIsPartOf<'a>>) -> Self {
        self._fields.86 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `keywords` field (optional)
    pub fn keywords(
        mut self,
        value: impl Into<Option<ImageObjectKeywords<'a>>>,
    ) -> Self {
        self._fields.87 = value.into();
        self
    }
    /// Set the `keywords` field to an Option value (optional)
    pub fn maybe_keywords(mut self, value: Option<ImageObjectKeywords<'a>>) -> Self {
        self._fields.87 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `learningResourceType` field (optional)
    pub fn learning_resource_type(
        mut self,
        value: impl Into<Option<ImageObjectLearningResourceType<'a>>>,
    ) -> Self {
        self._fields.88 = value.into();
        self
    }
    /// Set the `learningResourceType` field to an Option value (optional)
    pub fn maybe_learning_resource_type(
        mut self,
        value: Option<ImageObjectLearningResourceType<'a>>,
    ) -> Self {
        self._fields.88 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `license` field (optional)
    pub fn license(mut self, value: impl Into<Option<ImageObjectLicense<'a>>>) -> Self {
        self._fields.89 = value.into();
        self
    }
    /// Set the `license` field to an Option value (optional)
    pub fn maybe_license(mut self, value: Option<ImageObjectLicense<'a>>) -> Self {
        self._fields.89 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `locationCreated` field (optional)
    pub fn location_created(
        mut self,
        value: impl Into<Option<ImageObjectLocationCreated<'a>>>,
    ) -> Self {
        self._fields.90 = value.into();
        self
    }
    /// Set the `locationCreated` field to an Option value (optional)
    pub fn maybe_location_created(
        mut self,
        value: Option<ImageObjectLocationCreated<'a>>,
    ) -> Self {
        self._fields.90 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `mainEntity` field (optional)
    pub fn main_entity(
        mut self,
        value: impl Into<Option<ImageObjectMainEntity<'a>>>,
    ) -> Self {
        self._fields.91 = value.into();
        self
    }
    /// Set the `mainEntity` field to an Option value (optional)
    pub fn maybe_main_entity(
        mut self,
        value: Option<ImageObjectMainEntity<'a>>,
    ) -> Self {
        self._fields.91 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `mainEntityOfPage` field (optional)
    pub fn main_entity_of_page(
        mut self,
        value: impl Into<Option<ImageObjectMainEntityOfPage<'a>>>,
    ) -> Self {
        self._fields.92 = value.into();
        self
    }
    /// Set the `mainEntityOfPage` field to an Option value (optional)
    pub fn maybe_main_entity_of_page(
        mut self,
        value: Option<ImageObjectMainEntityOfPage<'a>>,
    ) -> Self {
        self._fields.92 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `maintainer` field (optional)
    pub fn maintainer(
        mut self,
        value: impl Into<Option<ImageObjectMaintainer<'a>>>,
    ) -> Self {
        self._fields.93 = value.into();
        self
    }
    /// Set the `maintainer` field to an Option value (optional)
    pub fn maybe_maintainer(mut self, value: Option<ImageObjectMaintainer<'a>>) -> Self {
        self._fields.93 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `material` field (optional)
    pub fn material(
        mut self,
        value: impl Into<Option<ImageObjectMaterial<'a>>>,
    ) -> Self {
        self._fields.94 = value.into();
        self
    }
    /// Set the `material` field to an Option value (optional)
    pub fn maybe_material(mut self, value: Option<ImageObjectMaterial<'a>>) -> Self {
        self._fields.94 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `materialExtent` field (optional)
    pub fn material_extent(
        mut self,
        value: impl Into<Option<ImageObjectMaterialExtent<'a>>>,
    ) -> Self {
        self._fields.95 = value.into();
        self
    }
    /// Set the `materialExtent` field to an Option value (optional)
    pub fn maybe_material_extent(
        mut self,
        value: Option<ImageObjectMaterialExtent<'a>>,
    ) -> Self {
        self._fields.95 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `mentions` field (optional)
    pub fn mentions(
        mut self,
        value: impl Into<Option<ImageObjectMentions<'a>>>,
    ) -> Self {
        self._fields.96 = value.into();
        self
    }
    /// Set the `mentions` field to an Option value (optional)
    pub fn maybe_mentions(mut self, value: Option<ImageObjectMentions<'a>>) -> Self {
        self._fields.96 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `name` field (optional)
    pub fn name(mut self, value: impl Into<Option<ImageObjectName<'a>>>) -> Self {
        self._fields.97 = value.into();
        self
    }
    /// Set the `name` field to an Option value (optional)
    pub fn maybe_name(mut self, value: Option<ImageObjectName<'a>>) -> Self {
        self._fields.97 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `offers` field (optional)
    pub fn offers(mut self, value: impl Into<Option<ImageObjectOffers<'a>>>) -> Self {
        self._fields.98 = value.into();
        self
    }
    /// Set the `offers` field to an Option value (optional)
    pub fn maybe_offers(mut self, value: Option<ImageObjectOffers<'a>>) -> Self {
        self._fields.98 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `pattern` field (optional)
    pub fn pattern(mut self, value: impl Into<Option<ImageObjectPattern<'a>>>) -> Self {
        self._fields.99 = value.into();
        self
    }
    /// Set the `pattern` field to an Option value (optional)
    pub fn maybe_pattern(mut self, value: Option<ImageObjectPattern<'a>>) -> Self {
        self._fields.99 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `playerType` field (optional)
    pub fn player_type(
        mut self,
        value: impl Into<Option<ImageObjectPlayerType<'a>>>,
    ) -> Self {
        self._fields.100 = value.into();
        self
    }
    /// Set the `playerType` field to an Option value (optional)
    pub fn maybe_player_type(
        mut self,
        value: Option<ImageObjectPlayerType<'a>>,
    ) -> Self {
        self._fields.100 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `position` field (optional)
    pub fn position(
        mut self,
        value: impl Into<Option<ImageObjectPosition<'a>>>,
    ) -> Self {
        self._fields.101 = value.into();
        self
    }
    /// Set the `position` field to an Option value (optional)
    pub fn maybe_position(mut self, value: Option<ImageObjectPosition<'a>>) -> Self {
        self._fields.101 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `potentialAction` field (optional)
    pub fn potential_action(
        mut self,
        value: impl Into<Option<ImageObjectPotentialAction<'a>>>,
    ) -> Self {
        self._fields.102 = value.into();
        self
    }
    /// Set the `potentialAction` field to an Option value (optional)
    pub fn maybe_potential_action(
        mut self,
        value: Option<ImageObjectPotentialAction<'a>>,
    ) -> Self {
        self._fields.102 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `producer` field (optional)
    pub fn producer(
        mut self,
        value: impl Into<Option<ImageObjectProducer<'a>>>,
    ) -> Self {
        self._fields.103 = value.into();
        self
    }
    /// Set the `producer` field to an Option value (optional)
    pub fn maybe_producer(mut self, value: Option<ImageObjectProducer<'a>>) -> Self {
        self._fields.103 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `productionCompany` field (optional)
    pub fn production_company(
        mut self,
        value: impl Into<Option<ImageObjectProductionCompany<'a>>>,
    ) -> Self {
        self._fields.104 = value.into();
        self
    }
    /// Set the `productionCompany` field to an Option value (optional)
    pub fn maybe_production_company(
        mut self,
        value: Option<ImageObjectProductionCompany<'a>>,
    ) -> Self {
        self._fields.104 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `provider` field (optional)
    pub fn provider(
        mut self,
        value: impl Into<Option<ImageObjectProvider<'a>>>,
    ) -> Self {
        self._fields.105 = value.into();
        self
    }
    /// Set the `provider` field to an Option value (optional)
    pub fn maybe_provider(mut self, value: Option<ImageObjectProvider<'a>>) -> Self {
        self._fields.105 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `publication` field (optional)
    pub fn publication(
        mut self,
        value: impl Into<Option<ImageObjectPublication<'a>>>,
    ) -> Self {
        self._fields.106 = value.into();
        self
    }
    /// Set the `publication` field to an Option value (optional)
    pub fn maybe_publication(
        mut self,
        value: Option<ImageObjectPublication<'a>>,
    ) -> Self {
        self._fields.106 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `publisher` field (optional)
    pub fn publisher(
        mut self,
        value: impl Into<Option<ImageObjectPublisher<'a>>>,
    ) -> Self {
        self._fields.107 = value.into();
        self
    }
    /// Set the `publisher` field to an Option value (optional)
    pub fn maybe_publisher(mut self, value: Option<ImageObjectPublisher<'a>>) -> Self {
        self._fields.107 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `publisherImprint` field (optional)
    pub fn publisher_imprint(
        mut self,
        value: impl Into<Option<ImageObjectPublisherImprint<'a>>>,
    ) -> Self {
        self._fields.108 = value.into();
        self
    }
    /// Set the `publisherImprint` field to an Option value (optional)
    pub fn maybe_publisher_imprint(
        mut self,
        value: Option<ImageObjectPublisherImprint<'a>>,
    ) -> Self {
        self._fields.108 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `publishingPrinciples` field (optional)
    pub fn publishing_principles(
        mut self,
        value: impl Into<Option<ImageObjectPublishingPrinciples<'a>>>,
    ) -> Self {
        self._fields.109 = value.into();
        self
    }
    /// Set the `publishingPrinciples` field to an Option value (optional)
    pub fn maybe_publishing_principles(
        mut self,
        value: Option<ImageObjectPublishingPrinciples<'a>>,
    ) -> Self {
        self._fields.109 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `recordedAt` field (optional)
    pub fn recorded_at(
        mut self,
        value: impl Into<Option<ImageObjectRecordedAt<'a>>>,
    ) -> Self {
        self._fields.110 = value.into();
        self
    }
    /// Set the `recordedAt` field to an Option value (optional)
    pub fn maybe_recorded_at(
        mut self,
        value: Option<ImageObjectRecordedAt<'a>>,
    ) -> Self {
        self._fields.110 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `regionsAllowed` field (optional)
    pub fn regions_allowed(
        mut self,
        value: impl Into<Option<ImageObjectRegionsAllowed<'a>>>,
    ) -> Self {
        self._fields.111 = value.into();
        self
    }
    /// Set the `regionsAllowed` field to an Option value (optional)
    pub fn maybe_regions_allowed(
        mut self,
        value: Option<ImageObjectRegionsAllowed<'a>>,
    ) -> Self {
        self._fields.111 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `releasedEvent` field (optional)
    pub fn released_event(
        mut self,
        value: impl Into<Option<ImageObjectReleasedEvent<'a>>>,
    ) -> Self {
        self._fields.112 = value.into();
        self
    }
    /// Set the `releasedEvent` field to an Option value (optional)
    pub fn maybe_released_event(
        mut self,
        value: Option<ImageObjectReleasedEvent<'a>>,
    ) -> Self {
        self._fields.112 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `representativeOfPage` field (optional)
    pub fn representative_of_page(
        mut self,
        value: impl Into<Option<ImageObjectRepresentativeOfPage<'a>>>,
    ) -> Self {
        self._fields.113 = value.into();
        self
    }
    /// Set the `representativeOfPage` field to an Option value (optional)
    pub fn maybe_representative_of_page(
        mut self,
        value: Option<ImageObjectRepresentativeOfPage<'a>>,
    ) -> Self {
        self._fields.113 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `requiresSubscription` field (optional)
    pub fn requires_subscription(
        mut self,
        value: impl Into<Option<ImageObjectRequiresSubscription<'a>>>,
    ) -> Self {
        self._fields.114 = value.into();
        self
    }
    /// Set the `requiresSubscription` field to an Option value (optional)
    pub fn maybe_requires_subscription(
        mut self,
        value: Option<ImageObjectRequiresSubscription<'a>>,
    ) -> Self {
        self._fields.114 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `review` field (optional)
    pub fn review(mut self, value: impl Into<Option<ImageObjectReview<'a>>>) -> Self {
        self._fields.115 = value.into();
        self
    }
    /// Set the `review` field to an Option value (optional)
    pub fn maybe_review(mut self, value: Option<ImageObjectReview<'a>>) -> Self {
        self._fields.115 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `reviews` field (optional)
    pub fn reviews(mut self, value: impl Into<Option<ImageObjectReviews<'a>>>) -> Self {
        self._fields.116 = value.into();
        self
    }
    /// Set the `reviews` field to an Option value (optional)
    pub fn maybe_reviews(mut self, value: Option<ImageObjectReviews<'a>>) -> Self {
        self._fields.116 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `sameAs` field (optional)
    pub fn same_as(mut self, value: impl Into<Option<ImageObjectSameAs<'a>>>) -> Self {
        self._fields.117 = value.into();
        self
    }
    /// Set the `sameAs` field to an Option value (optional)
    pub fn maybe_same_as(mut self, value: Option<ImageObjectSameAs<'a>>) -> Self {
        self._fields.117 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `schemaVersion` field (optional)
    pub fn schema_version(
        mut self,
        value: impl Into<Option<ImageObjectSchemaVersion<'a>>>,
    ) -> Self {
        self._fields.118 = value.into();
        self
    }
    /// Set the `schemaVersion` field to an Option value (optional)
    pub fn maybe_schema_version(
        mut self,
        value: Option<ImageObjectSchemaVersion<'a>>,
    ) -> Self {
        self._fields.118 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `sdDatePublished` field (optional)
    pub fn sd_date_published(
        mut self,
        value: impl Into<Option<ImageObjectSdDatePublished<'a>>>,
    ) -> Self {
        self._fields.119 = value.into();
        self
    }
    /// Set the `sdDatePublished` field to an Option value (optional)
    pub fn maybe_sd_date_published(
        mut self,
        value: Option<ImageObjectSdDatePublished<'a>>,
    ) -> Self {
        self._fields.119 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `sdLicense` field (optional)
    pub fn sd_license(
        mut self,
        value: impl Into<Option<ImageObjectSdLicense<'a>>>,
    ) -> Self {
        self._fields.120 = value.into();
        self
    }
    /// Set the `sdLicense` field to an Option value (optional)
    pub fn maybe_sd_license(mut self, value: Option<ImageObjectSdLicense<'a>>) -> Self {
        self._fields.120 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `sdPublisher` field (optional)
    pub fn sd_publisher(
        mut self,
        value: impl Into<Option<ImageObjectSdPublisher<'a>>>,
    ) -> Self {
        self._fields.121 = value.into();
        self
    }
    /// Set the `sdPublisher` field to an Option value (optional)
    pub fn maybe_sd_publisher(
        mut self,
        value: Option<ImageObjectSdPublisher<'a>>,
    ) -> Self {
        self._fields.121 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `sha256` field (optional)
    pub fn sha256(mut self, value: impl Into<Option<ImageObjectSha256<'a>>>) -> Self {
        self._fields.122 = value.into();
        self
    }
    /// Set the `sha256` field to an Option value (optional)
    pub fn maybe_sha256(mut self, value: Option<ImageObjectSha256<'a>>) -> Self {
        self._fields.122 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `size` field (optional)
    pub fn size(mut self, value: impl Into<Option<ImageObjectSize<'a>>>) -> Self {
        self._fields.123 = value.into();
        self
    }
    /// Set the `size` field to an Option value (optional)
    pub fn maybe_size(mut self, value: Option<ImageObjectSize<'a>>) -> Self {
        self._fields.123 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `sourceOrganization` field (optional)
    pub fn source_organization(
        mut self,
        value: impl Into<Option<ImageObjectSourceOrganization<'a>>>,
    ) -> Self {
        self._fields.124 = value.into();
        self
    }
    /// Set the `sourceOrganization` field to an Option value (optional)
    pub fn maybe_source_organization(
        mut self,
        value: Option<ImageObjectSourceOrganization<'a>>,
    ) -> Self {
        self._fields.124 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `spatial` field (optional)
    pub fn spatial(mut self, value: impl Into<Option<ImageObjectSpatial<'a>>>) -> Self {
        self._fields.125 = value.into();
        self
    }
    /// Set the `spatial` field to an Option value (optional)
    pub fn maybe_spatial(mut self, value: Option<ImageObjectSpatial<'a>>) -> Self {
        self._fields.125 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `spatialCoverage` field (optional)
    pub fn spatial_coverage(
        mut self,
        value: impl Into<Option<ImageObjectSpatialCoverage<'a>>>,
    ) -> Self {
        self._fields.126 = value.into();
        self
    }
    /// Set the `spatialCoverage` field to an Option value (optional)
    pub fn maybe_spatial_coverage(
        mut self,
        value: Option<ImageObjectSpatialCoverage<'a>>,
    ) -> Self {
        self._fields.126 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `sponsor` field (optional)
    pub fn sponsor(mut self, value: impl Into<Option<ImageObjectSponsor<'a>>>) -> Self {
        self._fields.127 = value.into();
        self
    }
    /// Set the `sponsor` field to an Option value (optional)
    pub fn maybe_sponsor(mut self, value: Option<ImageObjectSponsor<'a>>) -> Self {
        self._fields.127 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `startTime` field (optional)
    pub fn start_time(
        mut self,
        value: impl Into<Option<ImageObjectStartTime<'a>>>,
    ) -> Self {
        self._fields.128 = value.into();
        self
    }
    /// Set the `startTime` field to an Option value (optional)
    pub fn maybe_start_time(mut self, value: Option<ImageObjectStartTime<'a>>) -> Self {
        self._fields.128 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `subjectOf` field (optional)
    pub fn subject_of(
        mut self,
        value: impl Into<Option<ImageObjectSubjectOf<'a>>>,
    ) -> Self {
        self._fields.129 = value.into();
        self
    }
    /// Set the `subjectOf` field to an Option value (optional)
    pub fn maybe_subject_of(mut self, value: Option<ImageObjectSubjectOf<'a>>) -> Self {
        self._fields.129 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `teaches` field (optional)
    pub fn teaches(mut self, value: impl Into<Option<ImageObjectTeaches<'a>>>) -> Self {
        self._fields.130 = value.into();
        self
    }
    /// Set the `teaches` field to an Option value (optional)
    pub fn maybe_teaches(mut self, value: Option<ImageObjectTeaches<'a>>) -> Self {
        self._fields.130 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `temporal` field (optional)
    pub fn temporal(
        mut self,
        value: impl Into<Option<ImageObjectTemporal<'a>>>,
    ) -> Self {
        self._fields.131 = value.into();
        self
    }
    /// Set the `temporal` field to an Option value (optional)
    pub fn maybe_temporal(mut self, value: Option<ImageObjectTemporal<'a>>) -> Self {
        self._fields.131 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `temporalCoverage` field (optional)
    pub fn temporal_coverage(
        mut self,
        value: impl Into<Option<ImageObjectTemporalCoverage<'a>>>,
    ) -> Self {
        self._fields.132 = value.into();
        self
    }
    /// Set the `temporalCoverage` field to an Option value (optional)
    pub fn maybe_temporal_coverage(
        mut self,
        value: Option<ImageObjectTemporalCoverage<'a>>,
    ) -> Self {
        self._fields.132 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `text` field (optional)
    pub fn text(mut self, value: impl Into<Option<ImageObjectText<'a>>>) -> Self {
        self._fields.133 = value.into();
        self
    }
    /// Set the `text` field to an Option value (optional)
    pub fn maybe_text(mut self, value: Option<ImageObjectText<'a>>) -> Self {
        self._fields.133 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `thumbnail` field (optional)
    pub fn thumbnail(
        mut self,
        value: impl Into<Option<ImageObjectThumbnail<'a>>>,
    ) -> Self {
        self._fields.134 = value.into();
        self
    }
    /// Set the `thumbnail` field to an Option value (optional)
    pub fn maybe_thumbnail(mut self, value: Option<ImageObjectThumbnail<'a>>) -> Self {
        self._fields.134 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `thumbnailUrl` field (optional)
    pub fn thumbnail_url(
        mut self,
        value: impl Into<Option<ImageObjectThumbnailUrl<'a>>>,
    ) -> Self {
        self._fields.135 = value.into();
        self
    }
    /// Set the `thumbnailUrl` field to an Option value (optional)
    pub fn maybe_thumbnail_url(
        mut self,
        value: Option<ImageObjectThumbnailUrl<'a>>,
    ) -> Self {
        self._fields.135 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `timeRequired` field (optional)
    pub fn time_required(
        mut self,
        value: impl Into<Option<ImageObjectTimeRequired<'a>>>,
    ) -> Self {
        self._fields.136 = value.into();
        self
    }
    /// Set the `timeRequired` field to an Option value (optional)
    pub fn maybe_time_required(
        mut self,
        value: Option<ImageObjectTimeRequired<'a>>,
    ) -> Self {
        self._fields.136 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `translationOfWork` field (optional)
    pub fn translation_of_work(
        mut self,
        value: impl Into<Option<ImageObjectTranslationOfWork<'a>>>,
    ) -> Self {
        self._fields.137 = value.into();
        self
    }
    /// Set the `translationOfWork` field to an Option value (optional)
    pub fn maybe_translation_of_work(
        mut self,
        value: Option<ImageObjectTranslationOfWork<'a>>,
    ) -> Self {
        self._fields.137 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `translator` field (optional)
    pub fn translator(
        mut self,
        value: impl Into<Option<ImageObjectTranslator<'a>>>,
    ) -> Self {
        self._fields.138 = value.into();
        self
    }
    /// Set the `translator` field to an Option value (optional)
    pub fn maybe_translator(mut self, value: Option<ImageObjectTranslator<'a>>) -> Self {
        self._fields.138 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `typicalAgeRange` field (optional)
    pub fn typical_age_range(
        mut self,
        value: impl Into<Option<ImageObjectTypicalAgeRange<'a>>>,
    ) -> Self {
        self._fields.139 = value.into();
        self
    }
    /// Set the `typicalAgeRange` field to an Option value (optional)
    pub fn maybe_typical_age_range(
        mut self,
        value: Option<ImageObjectTypicalAgeRange<'a>>,
    ) -> Self {
        self._fields.139 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `uploadDate` field (optional)
    pub fn upload_date(
        mut self,
        value: impl Into<Option<ImageObjectUploadDate<'a>>>,
    ) -> Self {
        self._fields.140 = value.into();
        self
    }
    /// Set the `uploadDate` field to an Option value (optional)
    pub fn maybe_upload_date(
        mut self,
        value: Option<ImageObjectUploadDate<'a>>,
    ) -> Self {
        self._fields.140 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `url` field (optional)
    pub fn url(mut self, value: impl Into<Option<ImageObjectUrl<'a>>>) -> Self {
        self._fields.141 = value.into();
        self
    }
    /// Set the `url` field to an Option value (optional)
    pub fn maybe_url(mut self, value: Option<ImageObjectUrl<'a>>) -> Self {
        self._fields.141 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `usageInfo` field (optional)
    pub fn usage_info(
        mut self,
        value: impl Into<Option<ImageObjectUsageInfo<'a>>>,
    ) -> Self {
        self._fields.142 = value.into();
        self
    }
    /// Set the `usageInfo` field to an Option value (optional)
    pub fn maybe_usage_info(mut self, value: Option<ImageObjectUsageInfo<'a>>) -> Self {
        self._fields.142 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `version` field (optional)
    pub fn version(mut self, value: impl Into<Option<ImageObjectVersion<'a>>>) -> Self {
        self._fields.143 = value.into();
        self
    }
    /// Set the `version` field to an Option value (optional)
    pub fn maybe_version(mut self, value: Option<ImageObjectVersion<'a>>) -> Self {
        self._fields.143 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `video` field (optional)
    pub fn video(mut self, value: impl Into<Option<ImageObjectVideo<'a>>>) -> Self {
        self._fields.144 = value.into();
        self
    }
    /// Set the `video` field to an Option value (optional)
    pub fn maybe_video(mut self, value: Option<ImageObjectVideo<'a>>) -> Self {
        self._fields.144 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `width` field (optional)
    pub fn width(mut self, value: impl Into<Option<ImageObjectWidth<'a>>>) -> Self {
        self._fields.145 = value.into();
        self
    }
    /// Set the `width` field to an Option value (optional)
    pub fn maybe_width(mut self, value: Option<ImageObjectWidth<'a>>) -> Self {
        self._fields.145 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `wordCount` field (optional)
    pub fn word_count(
        mut self,
        value: impl Into<Option<ImageObjectWordCount<'a>>>,
    ) -> Self {
        self._fields.146 = value.into();
        self
    }
    /// Set the `wordCount` field to an Option value (optional)
    pub fn maybe_word_count(mut self, value: Option<ImageObjectWordCount<'a>>) -> Self {
        self._fields.146 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `workExample` field (optional)
    pub fn work_example(
        mut self,
        value: impl Into<Option<ImageObjectWorkExample<'a>>>,
    ) -> Self {
        self._fields.147 = value.into();
        self
    }
    /// Set the `workExample` field to an Option value (optional)
    pub fn maybe_work_example(
        mut self,
        value: Option<ImageObjectWorkExample<'a>>,
    ) -> Self {
        self._fields.147 = value;
        self
    }
}

impl<'a, S: image_object_state::State> ImageObjectBuilder<'a, S> {
    /// Set the `workTranslation` field (optional)
    pub fn work_translation(
        mut self,
        value: impl Into<Option<ImageObjectWorkTranslation<'a>>>,
    ) -> Self {
        self._fields.148 = value.into();
        self
    }
    /// Set the `workTranslation` field to an Option value (optional)
    pub fn maybe_work_translation(
        mut self,
        value: Option<ImageObjectWorkTranslation<'a>>,
    ) -> Self {
        self._fields.148 = value;
        self
    }
}

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