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

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

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

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

#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Serialize, Deserialize};
use crate::social_flockfeeds::lexical::r#type::brand;
use crate::social_flockfeeds::lexical::r#type::event;
use crate::social_flockfeeds::lexical::r#type::image_object;
use crate::social_flockfeeds::lexical::r#type::offer;
use crate::social_flockfeeds::lexical::r#type::organization;
use crate::social_flockfeeds::lexical::r#type::person;
use crate::social_flockfeeds::lexical::r#type::product;
/// A person (alive, dead, undead, or fictional).

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct Embedded<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_name: Option<EmbeddedAdditionalName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_type: Option<EmbeddedAdditionalType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<EmbeddedAddress<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub affiliation: Option<EmbeddedAffiliation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_interaction_statistic: Option<EmbeddedAgentInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternate_name: Option<EmbeddedAlternateName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alumni_of: Option<EmbeddedAlumniOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub award: Option<EmbeddedAward<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awards: Option<EmbeddedAwards<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub birth_date: Option<EmbeddedBirthDate<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub birth_place: Option<EmbeddedBirthPlace<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub brand: Option<EmbeddedBrand<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub call_sign: Option<EmbeddedCallSign<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub children: Option<EmbeddedChildren<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub colleague: Option<EmbeddedColleague<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub colleagues: Option<EmbeddedColleagues<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact_point: Option<EmbeddedContactPoint<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact_points: Option<EmbeddedContactPoints<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub death_date: Option<EmbeddedDeathDate<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub death_place: Option<EmbeddedDeathPlace<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<EmbeddedDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disambiguating_description: Option<EmbeddedDisambiguatingDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duns: Option<EmbeddedDuns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<EmbeddedEmail<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub family_name: Option<EmbeddedFamilyName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fax_number: Option<EmbeddedFaxNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub follows: Option<EmbeddedFollows<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funder: Option<EmbeddedFunder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funding: Option<EmbeddedFunding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub gender: Option<EmbeddedGender<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub given_name: Option<EmbeddedGivenName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub global_location_number: Option<EmbeddedGlobalLocationNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_certification: Option<EmbeddedHasCertification<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_credential: Option<EmbeddedHasCredential<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_occupation: Option<EmbeddedHasOccupation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_offer_catalog: Option<EmbeddedHasOfferCatalog<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_pos: Option<EmbeddedHasPos<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub height: Option<EmbeddedHeight<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub home_location: Option<EmbeddedHomeLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub honorific_prefix: Option<EmbeddedHonorificPrefix<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub honorific_suffix: Option<EmbeddedHonorificSuffix<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifier: Option<EmbeddedIdentifier<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<EmbeddedImage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interaction_statistic: Option<EmbeddedInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isic_v4: Option<EmbeddedIsicV4<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub job_title: Option<EmbeddedJobTitle<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows: Option<EmbeddedKnows<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows_about: Option<EmbeddedKnowsAbout<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows_language: Option<EmbeddedKnowsLanguage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity_of_page: Option<EmbeddedMainEntityOfPage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub makes_offer: Option<EmbeddedMakesOffer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_of: Option<EmbeddedMemberOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub naics: Option<EmbeddedNaics<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<EmbeddedName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nationality: Option<EmbeddedNationality<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub net_worth: Option<EmbeddedNetWorth<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub owns: Option<EmbeddedOwns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent: Option<EmbeddedParent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parents: Option<EmbeddedParents<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub performer_in: Option<EmbeddedPerformerIn<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub potential_action: Option<EmbeddedPotentialAction<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pronouns: Option<EmbeddedPronouns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publishing_principles: Option<EmbeddedPublishingPrinciples<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub related_to: Option<EmbeddedRelatedTo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub same_as: Option<EmbeddedSameAs<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seeks: Option<EmbeddedSeeks<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sibling: Option<EmbeddedSibling<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub siblings: Option<EmbeddedSiblings<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub skills: Option<EmbeddedSkills<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sponsor: Option<EmbeddedSponsor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spouse: Option<EmbeddedSpouse<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject_of: Option<EmbeddedSubjectOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tax_id: Option<EmbeddedTaxId<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telephone: Option<EmbeddedTelephone<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<EmbeddedUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vat_id: Option<EmbeddedVatId<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weight: Option<EmbeddedWeight<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_location: Option<EmbeddedWorkLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub works_for: Option<EmbeddedWorksFor<S>>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


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

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

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

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


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

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

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


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

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

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

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

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


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

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


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


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


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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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

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


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


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


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


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

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

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

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


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

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

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


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


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

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


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


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


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

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

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

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

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

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

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


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(
    rename_all = "camelCase",
    rename = "social.flockfeeds.lexical.type.Person",
    tag = "$type",
    bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct Person<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_name: Option<PersonAdditionalName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_type: Option<PersonAdditionalType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<PersonAddress<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub affiliation: Option<PersonAffiliation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_interaction_statistic: Option<PersonAgentInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternate_name: Option<PersonAlternateName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alumni_of: Option<PersonAlumniOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub award: Option<PersonAward<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awards: Option<PersonAwards<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub birth_date: Option<PersonBirthDate<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub birth_place: Option<PersonBirthPlace<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub brand: Option<PersonBrand<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub call_sign: Option<PersonCallSign<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub children: Option<PersonChildren<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub colleague: Option<PersonColleague<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub colleagues: Option<PersonColleagues<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact_point: Option<PersonContactPoint<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact_points: Option<PersonContactPoints<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub death_date: Option<PersonDeathDate<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub death_place: Option<PersonDeathPlace<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<PersonDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disambiguating_description: Option<PersonDisambiguatingDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duns: Option<PersonDuns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<PersonEmail<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub family_name: Option<PersonFamilyName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fax_number: Option<PersonFaxNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub follows: Option<PersonFollows<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funder: Option<PersonFunder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funding: Option<PersonFunding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub gender: Option<PersonGender<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub given_name: Option<PersonGivenName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub global_location_number: Option<PersonGlobalLocationNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_certification: Option<PersonHasCertification<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_credential: Option<PersonHasCredential<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_occupation: Option<PersonHasOccupation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_offer_catalog: Option<PersonHasOfferCatalog<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_pos: Option<PersonHasPos<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub height: Option<PersonHeight<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub home_location: Option<PersonHomeLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub honorific_prefix: Option<PersonHonorificPrefix<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub honorific_suffix: Option<PersonHonorificSuffix<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifier: Option<PersonIdentifier<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<PersonImage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interaction_statistic: Option<PersonInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isic_v4: Option<PersonIsicV4<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub job_title: Option<PersonJobTitle<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows: Option<PersonKnows<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows_about: Option<PersonKnowsAbout<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows_language: Option<PersonKnowsLanguage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity_of_page: Option<PersonMainEntityOfPage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub makes_offer: Option<PersonMakesOffer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_of: Option<PersonMemberOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub naics: Option<PersonNaics<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<PersonName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nationality: Option<PersonNationality<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub net_worth: Option<PersonNetWorth<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub owns: Option<PersonOwns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent: Option<PersonParent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parents: Option<PersonParents<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub performer_in: Option<PersonPerformerIn<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub potential_action: Option<PersonPotentialAction<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pronouns: Option<PersonPronouns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publishing_principles: Option<PersonPublishingPrinciples<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub related_to: Option<PersonRelatedTo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub same_as: Option<PersonSameAs<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seeks: Option<PersonSeeks<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sibling: Option<PersonSibling<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub siblings: Option<PersonSiblings<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub skills: Option<PersonSkills<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sponsor: Option<PersonSponsor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spouse: Option<PersonSpouse<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject_of: Option<PersonSubjectOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tax_id: Option<PersonTaxId<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telephone: Option<PersonTelephone<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<PersonUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vat_id: Option<PersonVatId<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weight: Option<PersonWeight<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_location: Option<PersonWorkLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub works_for: Option<PersonWorksFor<S>>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


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

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

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

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


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

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

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


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

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

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

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

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


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

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


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


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


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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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

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


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


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


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


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

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

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

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


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

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

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


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


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

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


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


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


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

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

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

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

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

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

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

/// 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 PersonGetRecordOutput<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cid: Option<Cid<S>>,
    pub uri: AtUri<S>,
    pub value: Person<S>,
}

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

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

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

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

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

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

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

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

fn lexicon_doc_social_flockfeeds_lexical_type_Person() -> 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.Person"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("embedded"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "A person (alive, dead, undead, or fictional).",
                        ),
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("additionalName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#additionalNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#additionalNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("additionalType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#additionalTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#additionalTypeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("address"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PostalAddress#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#addressScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#addressList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("affiliation"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#affiliationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("agentInteractionStatistic"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.InteractionCounter#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#agentInteractionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternateName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#alternateNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#alternateNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alumniOf"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.EducationalOrganization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#alumniOfList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("award"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#awardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#awardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("awards"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#awardsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#awardsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("birthDate"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#birthDateScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#birthDateList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("birthPlace"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#birthPlaceList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("brand"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Brand#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#brandList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("callSign"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#callSignScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#callSignList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("children"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#childrenList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("colleague"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#colleagueScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#colleagueList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("colleagues"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#colleaguesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contactPoint"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ContactPoint#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#contactPointList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("contactPoints"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ContactPoint#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#contactPointsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("deathDate"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#deathDateScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#deathDateList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("deathPlace"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#deathPlaceList")
                                ],
                                ..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.person#descriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#descriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("disambiguatingDescription"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#disambiguatingDescriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#disambiguatingDescriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("duns"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#dunsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#dunsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("email"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#emailScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#emailList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("familyName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#familyNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#familyNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("faxNumber"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#faxNumberScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#faxNumberList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("follows"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#followsList")
                                ],
                                ..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.person#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.person#fundingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("gender"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GenderType#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#genderScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#genderList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("givenName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#givenNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#givenNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("globalLocationNumber"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#globalLocationNumberScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#globalLocationNumberList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasCertification"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Certification#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#hasCertificationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasCredential"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.EducationalOccupationalCredential#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#hasCredentialList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasOccupation"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Occupation#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#hasOccupationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasOfferCatalog"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.OfferCatalog#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#hasOfferCatalogList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasPOS"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#hasPOSList")
                                ],
                                ..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.person#heightScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#heightList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("homeLocation"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ContactPoint#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#homeLocationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("honorificPrefix"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#honorificPrefixScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#honorificPrefixList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("honorificSuffix"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#honorificSuffixScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#honorificSuffixList")
                                ],
                                ..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.person#identifierScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#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.person#imageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#imageList")
                                ],
                                ..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.person#interactionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isicV4"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#isicV4Scalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#isicV4List")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("jobTitle"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#jobTitleScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#jobTitleList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("knows"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("knowsAbout"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Thing#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsAboutScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsAboutList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("knowsLanguage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Language#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsLanguageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsLanguageList")
                                ],
                                ..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.person#mainEntityOfPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#mainEntityOfPageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("makesOffer"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Offer#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#makesOfferList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("memberOf"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MemberProgramTier#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.ProgramMembership#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#memberOfList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("naics"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#naicsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#naicsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#nameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#nameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("nationality"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Country#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#nationalityList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("netWorth"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MonetaryAmount#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.PriceSpecification#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#netWorthList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("owns"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.OwnershipInfo#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Product#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#ownsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("parent"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#parentList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("parents"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#parentsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("performerIn"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#performerInList")
                                ],
                                ..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.person#potentialActionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("pronouns"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.StructuredValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#pronounsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#pronounsList")
                                ],
                                ..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.person#publishingPrinciplesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#publishingPrinciplesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("relatedTo"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#relatedToList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sameAs"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#sameAsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#sameAsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("seeks"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Demand#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#seeksList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sibling"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#siblingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("siblings"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#siblingsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("skills"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#skillsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#skillsList")
                                ],
                                ..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.person#sponsorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("spouse"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#spouseList")
                                ],
                                ..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.person#subjectOfList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("taxID"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#taxIDScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#taxIDList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("telephone"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#telephoneScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#telephoneList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("url"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#urlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#urlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("vatID"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#vatIDScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#vatIDList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("weight"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Mass#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#weightScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#weightList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("workLocation"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ContactPoint#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#workLocationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("worksFor"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.person#worksForList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("main"),
                LexUserType::Record(LexRecord {
                    key: Some(CowStr::new_static("tid")),
                    record: LexRecordRecord::Object(LexObject {
                        description: Some(
                            CowStr::new_static(
                                "A person (alive, dead, undead, or fictional).",
                            ),
                        ),
                        properties: {
                            #[allow(unused_mut)]
                            let mut map = BTreeMap::new();
                            map.insert(
                                SmolStr::new_static("additionalName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#additionalNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#additionalNameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("additionalType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#additionalTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#additionalTypeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("address"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.PostalAddress#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#addressScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#addressList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("affiliation"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#affiliationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("agentInteractionStatistic"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.InteractionCounter#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#agentInteractionStatisticList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alternateName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#alternateNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#alternateNameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alumniOf"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.EducationalOrganization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#alumniOfList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("award"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#awardScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#awardList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("awards"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#awardsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#awardsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("birthDate"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#birthDateScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#birthDateList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("birthPlace"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#birthPlaceList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("brand"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Brand#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#brandList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("callSign"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#callSignScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#callSignList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("children"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#childrenList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("colleague"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#colleagueScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#colleagueList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("colleagues"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#colleaguesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contactPoint"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ContactPoint#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#contactPointList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("contactPoints"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ContactPoint#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#contactPointsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("deathDate"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#deathDateScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#deathDateList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("deathPlace"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#deathPlaceList")
                                    ],
                                    ..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.person#descriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#descriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("disambiguatingDescription"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#disambiguatingDescriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#disambiguatingDescriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("duns"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#dunsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#dunsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("email"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#emailScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#emailList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("familyName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#familyNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#familyNameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("faxNumber"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#faxNumberScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#faxNumberList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("follows"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#followsList")
                                    ],
                                    ..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.person#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.person#fundingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("gender"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GenderType#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#genderScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#genderList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("givenName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#givenNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#givenNameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("globalLocationNumber"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#globalLocationNumberScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#globalLocationNumberList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasCertification"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Certification#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#hasCertificationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasCredential"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.EducationalOccupationalCredential#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#hasCredentialList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasOccupation"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Occupation#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#hasOccupationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasOfferCatalog"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.OfferCatalog#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#hasOfferCatalogList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasPOS"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#hasPOSList")
                                    ],
                                    ..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.person#heightScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#heightList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("homeLocation"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ContactPoint#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#homeLocationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("honorificPrefix"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#honorificPrefixScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#honorificPrefixList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("honorificSuffix"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#honorificSuffixScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#honorificSuffixList")
                                    ],
                                    ..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.person#identifierScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#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.person#imageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#imageList")
                                    ],
                                    ..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.person#interactionStatisticList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isicV4"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#isicV4Scalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#isicV4List")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("jobTitle"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#jobTitleScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#jobTitleList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("knows"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("knowsAbout"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Thing#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsAboutScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsAboutList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("knowsLanguage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Language#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsLanguageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#knowsLanguageList")
                                    ],
                                    ..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.person#mainEntityOfPageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#mainEntityOfPageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("makesOffer"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Offer#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#makesOfferList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("memberOf"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MemberProgramTier#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.ProgramMembership#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#memberOfList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("naics"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#naicsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#naicsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("name"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#nameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#nameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("nationality"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Country#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#nationalityList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("netWorth"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MonetaryAmount#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.PriceSpecification#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#netWorthList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("owns"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.OwnershipInfo#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Product#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#ownsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("parent"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#parentList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("parents"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#parentsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("performerIn"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#performerInList")
                                    ],
                                    ..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.person#potentialActionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("pronouns"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.StructuredValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#pronounsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#pronounsList")
                                    ],
                                    ..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.person#publishingPrinciplesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#publishingPrinciplesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("relatedTo"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#relatedToList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sameAs"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#sameAsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#sameAsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("seeks"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Demand#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#seeksList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sibling"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#siblingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("siblings"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#siblingsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("skills"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#skillsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#skillsList")
                                    ],
                                    ..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.person#sponsorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("spouse"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#spouseList")
                                    ],
                                    ..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.person#subjectOfList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("taxID"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#taxIDScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#taxIDList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("telephone"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#telephoneScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#telephoneList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("url"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#urlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#urlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("vatID"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#vatIDScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#vatIDList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("weight"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Mass#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#weightScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#weightList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("workLocation"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ContactPoint#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#workLocationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("worksFor"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.person#worksForList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map
                        },
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}

pub mod person_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 PersonBuilder<St: person_state::State, S: BosStr = DefaultStr> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<PersonAdditionalName<S>>,
        Option<PersonAdditionalType<S>>,
        Option<PersonAddress<S>>,
        Option<PersonAffiliation<S>>,
        Option<PersonAgentInteractionStatistic<S>>,
        Option<PersonAlternateName<S>>,
        Option<PersonAlumniOf<S>>,
        Option<PersonAward<S>>,
        Option<PersonAwards<S>>,
        Option<PersonBirthDate<S>>,
        Option<PersonBirthPlace<S>>,
        Option<PersonBrand<S>>,
        Option<PersonCallSign<S>>,
        Option<PersonChildren<S>>,
        Option<PersonColleague<S>>,
        Option<PersonColleagues<S>>,
        Option<PersonContactPoint<S>>,
        Option<PersonContactPoints<S>>,
        Option<PersonDeathDate<S>>,
        Option<PersonDeathPlace<S>>,
        Option<PersonDescription<S>>,
        Option<PersonDisambiguatingDescription<S>>,
        Option<PersonDuns<S>>,
        Option<PersonEmail<S>>,
        Option<PersonFamilyName<S>>,
        Option<PersonFaxNumber<S>>,
        Option<PersonFollows<S>>,
        Option<PersonFunder<S>>,
        Option<PersonFunding<S>>,
        Option<PersonGender<S>>,
        Option<PersonGivenName<S>>,
        Option<PersonGlobalLocationNumber<S>>,
        Option<PersonHasCertification<S>>,
        Option<PersonHasCredential<S>>,
        Option<PersonHasOccupation<S>>,
        Option<PersonHasOfferCatalog<S>>,
        Option<PersonHasPos<S>>,
        Option<PersonHeight<S>>,
        Option<PersonHomeLocation<S>>,
        Option<PersonHonorificPrefix<S>>,
        Option<PersonHonorificSuffix<S>>,
        Option<PersonIdentifier<S>>,
        Option<PersonImage<S>>,
        Option<PersonInteractionStatistic<S>>,
        Option<PersonIsicV4<S>>,
        Option<PersonJobTitle<S>>,
        Option<PersonKnows<S>>,
        Option<PersonKnowsAbout<S>>,
        Option<PersonKnowsLanguage<S>>,
        Option<PersonMainEntityOfPage<S>>,
        Option<PersonMakesOffer<S>>,
        Option<PersonMemberOf<S>>,
        Option<PersonNaics<S>>,
        Option<PersonName<S>>,
        Option<PersonNationality<S>>,
        Option<PersonNetWorth<S>>,
        Option<PersonOwns<S>>,
        Option<PersonParent<S>>,
        Option<PersonParents<S>>,
        Option<PersonPerformerIn<S>>,
        Option<PersonPotentialAction<S>>,
        Option<PersonPronouns<S>>,
        Option<PersonPublishingPrinciples<S>>,
        Option<PersonRelatedTo<S>>,
        Option<PersonSameAs<S>>,
        Option<PersonSeeks<S>>,
        Option<PersonSibling<S>>,
        Option<PersonSiblings<S>>,
        Option<PersonSkills<S>>,
        Option<PersonSponsor<S>>,
        Option<PersonSpouse<S>>,
        Option<PersonSubjectOf<S>>,
        Option<PersonTaxId<S>>,
        Option<PersonTelephone<S>>,
        Option<PersonUrl<S>>,
        Option<PersonVatId<S>>,
        Option<PersonWeight<S>>,
        Option<PersonWorkLocation<S>>,
        Option<PersonWorksFor<S>>,
    ),
    _type: PhantomData<fn() -> S>,
}

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

impl<S: BosStr> Person<S> {
    /// Create a new builder for this type
    pub fn builder() -> PersonBuilder<person_state::Empty, S> {
        PersonBuilder::builder()
    }
}

impl PersonBuilder<person_state::Empty, DefaultStr> {
    /// Create a new builder with all fields unset, using the default string type, if needed
    pub fn new() -> Self {
        PersonBuilder {
            _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,
            ),
            _type: PhantomData,
        }
    }
}

impl<S: BosStr> PersonBuilder<person_state::Empty, S> {
    /// Create a new builder with all fields unset
    pub fn builder() -> Self {
        PersonBuilder {
            _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,
            ),
            _type: PhantomData,
        }
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `additionalName` field (optional)
    pub fn additional_name(
        mut self,
        value: impl Into<Option<PersonAdditionalName<S>>>,
    ) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `additionalName` field to an Option value (optional)
    pub fn maybe_additional_name(
        mut self,
        value: Option<PersonAdditionalName<S>>,
    ) -> Self {
        self._fields.0 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `address` field (optional)
    pub fn address(mut self, value: impl Into<Option<PersonAddress<S>>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `address` field to an Option value (optional)
    pub fn maybe_address(mut self, value: Option<PersonAddress<S>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `affiliation` field (optional)
    pub fn affiliation(
        mut self,
        value: impl Into<Option<PersonAffiliation<S>>>,
    ) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `affiliation` field to an Option value (optional)
    pub fn maybe_affiliation(mut self, value: Option<PersonAffiliation<S>>) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `agentInteractionStatistic` field (optional)
    pub fn agent_interaction_statistic(
        mut self,
        value: impl Into<Option<PersonAgentInteractionStatistic<S>>>,
    ) -> Self {
        self._fields.4 = value.into();
        self
    }
    /// Set the `agentInteractionStatistic` field to an Option value (optional)
    pub fn maybe_agent_interaction_statistic(
        mut self,
        value: Option<PersonAgentInteractionStatistic<S>>,
    ) -> Self {
        self._fields.4 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `alumniOf` field (optional)
    pub fn alumni_of(mut self, value: impl Into<Option<PersonAlumniOf<S>>>) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `alumniOf` field to an Option value (optional)
    pub fn maybe_alumni_of(mut self, value: Option<PersonAlumniOf<S>>) -> Self {
        self._fields.6 = value;
        self
    }
}

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

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `birthDate` field (optional)
    pub fn birth_date(mut self, value: impl Into<Option<PersonBirthDate<S>>>) -> Self {
        self._fields.9 = value.into();
        self
    }
    /// Set the `birthDate` field to an Option value (optional)
    pub fn maybe_birth_date(mut self, value: Option<PersonBirthDate<S>>) -> Self {
        self._fields.9 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `birthPlace` field (optional)
    pub fn birth_place(mut self, value: impl Into<Option<PersonBirthPlace<S>>>) -> Self {
        self._fields.10 = value.into();
        self
    }
    /// Set the `birthPlace` field to an Option value (optional)
    pub fn maybe_birth_place(mut self, value: Option<PersonBirthPlace<S>>) -> Self {
        self._fields.10 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `brand` field (optional)
    pub fn brand(mut self, value: impl Into<Option<PersonBrand<S>>>) -> Self {
        self._fields.11 = value.into();
        self
    }
    /// Set the `brand` field to an Option value (optional)
    pub fn maybe_brand(mut self, value: Option<PersonBrand<S>>) -> Self {
        self._fields.11 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `callSign` field (optional)
    pub fn call_sign(mut self, value: impl Into<Option<PersonCallSign<S>>>) -> Self {
        self._fields.12 = value.into();
        self
    }
    /// Set the `callSign` field to an Option value (optional)
    pub fn maybe_call_sign(mut self, value: Option<PersonCallSign<S>>) -> Self {
        self._fields.12 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `children` field (optional)
    pub fn children(mut self, value: impl Into<Option<PersonChildren<S>>>) -> Self {
        self._fields.13 = value.into();
        self
    }
    /// Set the `children` field to an Option value (optional)
    pub fn maybe_children(mut self, value: Option<PersonChildren<S>>) -> Self {
        self._fields.13 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `colleague` field (optional)
    pub fn colleague(mut self, value: impl Into<Option<PersonColleague<S>>>) -> Self {
        self._fields.14 = value.into();
        self
    }
    /// Set the `colleague` field to an Option value (optional)
    pub fn maybe_colleague(mut self, value: Option<PersonColleague<S>>) -> Self {
        self._fields.14 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `colleagues` field (optional)
    pub fn colleagues(mut self, value: impl Into<Option<PersonColleagues<S>>>) -> Self {
        self._fields.15 = value.into();
        self
    }
    /// Set the `colleagues` field to an Option value (optional)
    pub fn maybe_colleagues(mut self, value: Option<PersonColleagues<S>>) -> Self {
        self._fields.15 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `contactPoint` field (optional)
    pub fn contact_point(
        mut self,
        value: impl Into<Option<PersonContactPoint<S>>>,
    ) -> Self {
        self._fields.16 = value.into();
        self
    }
    /// Set the `contactPoint` field to an Option value (optional)
    pub fn maybe_contact_point(mut self, value: Option<PersonContactPoint<S>>) -> Self {
        self._fields.16 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `contactPoints` field (optional)
    pub fn contact_points(
        mut self,
        value: impl Into<Option<PersonContactPoints<S>>>,
    ) -> Self {
        self._fields.17 = value.into();
        self
    }
    /// Set the `contactPoints` field to an Option value (optional)
    pub fn maybe_contact_points(
        mut self,
        value: Option<PersonContactPoints<S>>,
    ) -> Self {
        self._fields.17 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `deathDate` field (optional)
    pub fn death_date(mut self, value: impl Into<Option<PersonDeathDate<S>>>) -> Self {
        self._fields.18 = value.into();
        self
    }
    /// Set the `deathDate` field to an Option value (optional)
    pub fn maybe_death_date(mut self, value: Option<PersonDeathDate<S>>) -> Self {
        self._fields.18 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `deathPlace` field (optional)
    pub fn death_place(mut self, value: impl Into<Option<PersonDeathPlace<S>>>) -> Self {
        self._fields.19 = value.into();
        self
    }
    /// Set the `deathPlace` field to an Option value (optional)
    pub fn maybe_death_place(mut self, value: Option<PersonDeathPlace<S>>) -> Self {
        self._fields.19 = value;
        self
    }
}

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

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `duns` field (optional)
    pub fn duns(mut self, value: impl Into<Option<PersonDuns<S>>>) -> Self {
        self._fields.22 = value.into();
        self
    }
    /// Set the `duns` field to an Option value (optional)
    pub fn maybe_duns(mut self, value: Option<PersonDuns<S>>) -> Self {
        self._fields.22 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `email` field (optional)
    pub fn email(mut self, value: impl Into<Option<PersonEmail<S>>>) -> Self {
        self._fields.23 = value.into();
        self
    }
    /// Set the `email` field to an Option value (optional)
    pub fn maybe_email(mut self, value: Option<PersonEmail<S>>) -> Self {
        self._fields.23 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `familyName` field (optional)
    pub fn family_name(mut self, value: impl Into<Option<PersonFamilyName<S>>>) -> Self {
        self._fields.24 = value.into();
        self
    }
    /// Set the `familyName` field to an Option value (optional)
    pub fn maybe_family_name(mut self, value: Option<PersonFamilyName<S>>) -> Self {
        self._fields.24 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `faxNumber` field (optional)
    pub fn fax_number(mut self, value: impl Into<Option<PersonFaxNumber<S>>>) -> Self {
        self._fields.25 = value.into();
        self
    }
    /// Set the `faxNumber` field to an Option value (optional)
    pub fn maybe_fax_number(mut self, value: Option<PersonFaxNumber<S>>) -> Self {
        self._fields.25 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `follows` field (optional)
    pub fn follows(mut self, value: impl Into<Option<PersonFollows<S>>>) -> Self {
        self._fields.26 = value.into();
        self
    }
    /// Set the `follows` field to an Option value (optional)
    pub fn maybe_follows(mut self, value: Option<PersonFollows<S>>) -> Self {
        self._fields.26 = value;
        self
    }
}

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

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `gender` field (optional)
    pub fn gender(mut self, value: impl Into<Option<PersonGender<S>>>) -> Self {
        self._fields.29 = value.into();
        self
    }
    /// Set the `gender` field to an Option value (optional)
    pub fn maybe_gender(mut self, value: Option<PersonGender<S>>) -> Self {
        self._fields.29 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `givenName` field (optional)
    pub fn given_name(mut self, value: impl Into<Option<PersonGivenName<S>>>) -> Self {
        self._fields.30 = value.into();
        self
    }
    /// Set the `givenName` field to an Option value (optional)
    pub fn maybe_given_name(mut self, value: Option<PersonGivenName<S>>) -> Self {
        self._fields.30 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `globalLocationNumber` field (optional)
    pub fn global_location_number(
        mut self,
        value: impl Into<Option<PersonGlobalLocationNumber<S>>>,
    ) -> Self {
        self._fields.31 = value.into();
        self
    }
    /// Set the `globalLocationNumber` field to an Option value (optional)
    pub fn maybe_global_location_number(
        mut self,
        value: Option<PersonGlobalLocationNumber<S>>,
    ) -> Self {
        self._fields.31 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `hasCertification` field (optional)
    pub fn has_certification(
        mut self,
        value: impl Into<Option<PersonHasCertification<S>>>,
    ) -> Self {
        self._fields.32 = value.into();
        self
    }
    /// Set the `hasCertification` field to an Option value (optional)
    pub fn maybe_has_certification(
        mut self,
        value: Option<PersonHasCertification<S>>,
    ) -> Self {
        self._fields.32 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `hasCredential` field (optional)
    pub fn has_credential(
        mut self,
        value: impl Into<Option<PersonHasCredential<S>>>,
    ) -> Self {
        self._fields.33 = value.into();
        self
    }
    /// Set the `hasCredential` field to an Option value (optional)
    pub fn maybe_has_credential(
        mut self,
        value: Option<PersonHasCredential<S>>,
    ) -> Self {
        self._fields.33 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `hasOccupation` field (optional)
    pub fn has_occupation(
        mut self,
        value: impl Into<Option<PersonHasOccupation<S>>>,
    ) -> Self {
        self._fields.34 = value.into();
        self
    }
    /// Set the `hasOccupation` field to an Option value (optional)
    pub fn maybe_has_occupation(
        mut self,
        value: Option<PersonHasOccupation<S>>,
    ) -> Self {
        self._fields.34 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `hasOfferCatalog` field (optional)
    pub fn has_offer_catalog(
        mut self,
        value: impl Into<Option<PersonHasOfferCatalog<S>>>,
    ) -> Self {
        self._fields.35 = value.into();
        self
    }
    /// Set the `hasOfferCatalog` field to an Option value (optional)
    pub fn maybe_has_offer_catalog(
        mut self,
        value: Option<PersonHasOfferCatalog<S>>,
    ) -> Self {
        self._fields.35 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `hasPOS` field (optional)
    pub fn has_pos(mut self, value: impl Into<Option<PersonHasPos<S>>>) -> Self {
        self._fields.36 = value.into();
        self
    }
    /// Set the `hasPOS` field to an Option value (optional)
    pub fn maybe_has_pos(mut self, value: Option<PersonHasPos<S>>) -> Self {
        self._fields.36 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `height` field (optional)
    pub fn height(mut self, value: impl Into<Option<PersonHeight<S>>>) -> Self {
        self._fields.37 = value.into();
        self
    }
    /// Set the `height` field to an Option value (optional)
    pub fn maybe_height(mut self, value: Option<PersonHeight<S>>) -> Self {
        self._fields.37 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `homeLocation` field (optional)
    pub fn home_location(
        mut self,
        value: impl Into<Option<PersonHomeLocation<S>>>,
    ) -> Self {
        self._fields.38 = value.into();
        self
    }
    /// Set the `homeLocation` field to an Option value (optional)
    pub fn maybe_home_location(mut self, value: Option<PersonHomeLocation<S>>) -> Self {
        self._fields.38 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `honorificPrefix` field (optional)
    pub fn honorific_prefix(
        mut self,
        value: impl Into<Option<PersonHonorificPrefix<S>>>,
    ) -> Self {
        self._fields.39 = value.into();
        self
    }
    /// Set the `honorificPrefix` field to an Option value (optional)
    pub fn maybe_honorific_prefix(
        mut self,
        value: Option<PersonHonorificPrefix<S>>,
    ) -> Self {
        self._fields.39 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `honorificSuffix` field (optional)
    pub fn honorific_suffix(
        mut self,
        value: impl Into<Option<PersonHonorificSuffix<S>>>,
    ) -> Self {
        self._fields.40 = value.into();
        self
    }
    /// Set the `honorificSuffix` field to an Option value (optional)
    pub fn maybe_honorific_suffix(
        mut self,
        value: Option<PersonHonorificSuffix<S>>,
    ) -> Self {
        self._fields.40 = value;
        self
    }
}

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

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

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `isicV4` field (optional)
    pub fn isic_v4(mut self, value: impl Into<Option<PersonIsicV4<S>>>) -> Self {
        self._fields.44 = value.into();
        self
    }
    /// Set the `isicV4` field to an Option value (optional)
    pub fn maybe_isic_v4(mut self, value: Option<PersonIsicV4<S>>) -> Self {
        self._fields.44 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `jobTitle` field (optional)
    pub fn job_title(mut self, value: impl Into<Option<PersonJobTitle<S>>>) -> Self {
        self._fields.45 = value.into();
        self
    }
    /// Set the `jobTitle` field to an Option value (optional)
    pub fn maybe_job_title(mut self, value: Option<PersonJobTitle<S>>) -> Self {
        self._fields.45 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `knows` field (optional)
    pub fn knows(mut self, value: impl Into<Option<PersonKnows<S>>>) -> Self {
        self._fields.46 = value.into();
        self
    }
    /// Set the `knows` field to an Option value (optional)
    pub fn maybe_knows(mut self, value: Option<PersonKnows<S>>) -> Self {
        self._fields.46 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `knowsAbout` field (optional)
    pub fn knows_about(mut self, value: impl Into<Option<PersonKnowsAbout<S>>>) -> Self {
        self._fields.47 = value.into();
        self
    }
    /// Set the `knowsAbout` field to an Option value (optional)
    pub fn maybe_knows_about(mut self, value: Option<PersonKnowsAbout<S>>) -> Self {
        self._fields.47 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `knowsLanguage` field (optional)
    pub fn knows_language(
        mut self,
        value: impl Into<Option<PersonKnowsLanguage<S>>>,
    ) -> Self {
        self._fields.48 = value.into();
        self
    }
    /// Set the `knowsLanguage` field to an Option value (optional)
    pub fn maybe_knows_language(
        mut self,
        value: Option<PersonKnowsLanguage<S>>,
    ) -> Self {
        self._fields.48 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `makesOffer` field (optional)
    pub fn makes_offer(mut self, value: impl Into<Option<PersonMakesOffer<S>>>) -> Self {
        self._fields.50 = value.into();
        self
    }
    /// Set the `makesOffer` field to an Option value (optional)
    pub fn maybe_makes_offer(mut self, value: Option<PersonMakesOffer<S>>) -> Self {
        self._fields.50 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `memberOf` field (optional)
    pub fn member_of(mut self, value: impl Into<Option<PersonMemberOf<S>>>) -> Self {
        self._fields.51 = value.into();
        self
    }
    /// Set the `memberOf` field to an Option value (optional)
    pub fn maybe_member_of(mut self, value: Option<PersonMemberOf<S>>) -> Self {
        self._fields.51 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `naics` field (optional)
    pub fn naics(mut self, value: impl Into<Option<PersonNaics<S>>>) -> Self {
        self._fields.52 = value.into();
        self
    }
    /// Set the `naics` field to an Option value (optional)
    pub fn maybe_naics(mut self, value: Option<PersonNaics<S>>) -> Self {
        self._fields.52 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `nationality` field (optional)
    pub fn nationality(
        mut self,
        value: impl Into<Option<PersonNationality<S>>>,
    ) -> Self {
        self._fields.54 = value.into();
        self
    }
    /// Set the `nationality` field to an Option value (optional)
    pub fn maybe_nationality(mut self, value: Option<PersonNationality<S>>) -> Self {
        self._fields.54 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `netWorth` field (optional)
    pub fn net_worth(mut self, value: impl Into<Option<PersonNetWorth<S>>>) -> Self {
        self._fields.55 = value.into();
        self
    }
    /// Set the `netWorth` field to an Option value (optional)
    pub fn maybe_net_worth(mut self, value: Option<PersonNetWorth<S>>) -> Self {
        self._fields.55 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `owns` field (optional)
    pub fn owns(mut self, value: impl Into<Option<PersonOwns<S>>>) -> Self {
        self._fields.56 = value.into();
        self
    }
    /// Set the `owns` field to an Option value (optional)
    pub fn maybe_owns(mut self, value: Option<PersonOwns<S>>) -> Self {
        self._fields.56 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `parent` field (optional)
    pub fn parent(mut self, value: impl Into<Option<PersonParent<S>>>) -> Self {
        self._fields.57 = value.into();
        self
    }
    /// Set the `parent` field to an Option value (optional)
    pub fn maybe_parent(mut self, value: Option<PersonParent<S>>) -> Self {
        self._fields.57 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `parents` field (optional)
    pub fn parents(mut self, value: impl Into<Option<PersonParents<S>>>) -> Self {
        self._fields.58 = value.into();
        self
    }
    /// Set the `parents` field to an Option value (optional)
    pub fn maybe_parents(mut self, value: Option<PersonParents<S>>) -> Self {
        self._fields.58 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `performerIn` field (optional)
    pub fn performer_in(
        mut self,
        value: impl Into<Option<PersonPerformerIn<S>>>,
    ) -> Self {
        self._fields.59 = value.into();
        self
    }
    /// Set the `performerIn` field to an Option value (optional)
    pub fn maybe_performer_in(mut self, value: Option<PersonPerformerIn<S>>) -> Self {
        self._fields.59 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `pronouns` field (optional)
    pub fn pronouns(mut self, value: impl Into<Option<PersonPronouns<S>>>) -> Self {
        self._fields.61 = value.into();
        self
    }
    /// Set the `pronouns` field to an Option value (optional)
    pub fn maybe_pronouns(mut self, value: Option<PersonPronouns<S>>) -> Self {
        self._fields.61 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `relatedTo` field (optional)
    pub fn related_to(mut self, value: impl Into<Option<PersonRelatedTo<S>>>) -> Self {
        self._fields.63 = value.into();
        self
    }
    /// Set the `relatedTo` field to an Option value (optional)
    pub fn maybe_related_to(mut self, value: Option<PersonRelatedTo<S>>) -> Self {
        self._fields.63 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `seeks` field (optional)
    pub fn seeks(mut self, value: impl Into<Option<PersonSeeks<S>>>) -> Self {
        self._fields.65 = value.into();
        self
    }
    /// Set the `seeks` field to an Option value (optional)
    pub fn maybe_seeks(mut self, value: Option<PersonSeeks<S>>) -> Self {
        self._fields.65 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `sibling` field (optional)
    pub fn sibling(mut self, value: impl Into<Option<PersonSibling<S>>>) -> Self {
        self._fields.66 = value.into();
        self
    }
    /// Set the `sibling` field to an Option value (optional)
    pub fn maybe_sibling(mut self, value: Option<PersonSibling<S>>) -> Self {
        self._fields.66 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `siblings` field (optional)
    pub fn siblings(mut self, value: impl Into<Option<PersonSiblings<S>>>) -> Self {
        self._fields.67 = value.into();
        self
    }
    /// Set the `siblings` field to an Option value (optional)
    pub fn maybe_siblings(mut self, value: Option<PersonSiblings<S>>) -> Self {
        self._fields.67 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `skills` field (optional)
    pub fn skills(mut self, value: impl Into<Option<PersonSkills<S>>>) -> Self {
        self._fields.68 = value.into();
        self
    }
    /// Set the `skills` field to an Option value (optional)
    pub fn maybe_skills(mut self, value: Option<PersonSkills<S>>) -> Self {
        self._fields.68 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `spouse` field (optional)
    pub fn spouse(mut self, value: impl Into<Option<PersonSpouse<S>>>) -> Self {
        self._fields.70 = value.into();
        self
    }
    /// Set the `spouse` field to an Option value (optional)
    pub fn maybe_spouse(mut self, value: Option<PersonSpouse<S>>) -> Self {
        self._fields.70 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `taxID` field (optional)
    pub fn tax_id(mut self, value: impl Into<Option<PersonTaxId<S>>>) -> Self {
        self._fields.72 = value.into();
        self
    }
    /// Set the `taxID` field to an Option value (optional)
    pub fn maybe_tax_id(mut self, value: Option<PersonTaxId<S>>) -> Self {
        self._fields.72 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `telephone` field (optional)
    pub fn telephone(mut self, value: impl Into<Option<PersonTelephone<S>>>) -> Self {
        self._fields.73 = value.into();
        self
    }
    /// Set the `telephone` field to an Option value (optional)
    pub fn maybe_telephone(mut self, value: Option<PersonTelephone<S>>) -> Self {
        self._fields.73 = value;
        self
    }
}

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

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `vatID` field (optional)
    pub fn vat_id(mut self, value: impl Into<Option<PersonVatId<S>>>) -> Self {
        self._fields.75 = value.into();
        self
    }
    /// Set the `vatID` field to an Option value (optional)
    pub fn maybe_vat_id(mut self, value: Option<PersonVatId<S>>) -> Self {
        self._fields.75 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `weight` field (optional)
    pub fn weight(mut self, value: impl Into<Option<PersonWeight<S>>>) -> Self {
        self._fields.76 = value.into();
        self
    }
    /// Set the `weight` field to an Option value (optional)
    pub fn maybe_weight(mut self, value: Option<PersonWeight<S>>) -> Self {
        self._fields.76 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `workLocation` field (optional)
    pub fn work_location(
        mut self,
        value: impl Into<Option<PersonWorkLocation<S>>>,
    ) -> Self {
        self._fields.77 = value.into();
        self
    }
    /// Set the `workLocation` field to an Option value (optional)
    pub fn maybe_work_location(mut self, value: Option<PersonWorkLocation<S>>) -> Self {
        self._fields.77 = value;
        self
    }
}

impl<St: person_state::State, S: BosStr> PersonBuilder<St, S> {
    /// Set the `worksFor` field (optional)
    pub fn works_for(mut self, value: impl Into<Option<PersonWorksFor<S>>>) -> Self {
        self._fields.78 = value.into();
        self
    }
    /// Set the `worksFor` field to an Option value (optional)
    pub fn maybe_works_for(mut self, value: Option<PersonWorksFor<S>>) -> Self {
        self._fields.78 = value;
        self
    }
}

impl<St, S: BosStr> PersonBuilder<St, S>
where
    St: person_state::State,
{
    /// Build the final struct.
    pub fn build(self) -> Person<S> {
        Person {
            additional_name: self._fields.0,
            additional_type: self._fields.1,
            address: self._fields.2,
            affiliation: self._fields.3,
            agent_interaction_statistic: self._fields.4,
            alternate_name: self._fields.5,
            alumni_of: self._fields.6,
            award: self._fields.7,
            awards: self._fields.8,
            birth_date: self._fields.9,
            birth_place: self._fields.10,
            brand: self._fields.11,
            call_sign: self._fields.12,
            children: self._fields.13,
            colleague: self._fields.14,
            colleagues: self._fields.15,
            contact_point: self._fields.16,
            contact_points: self._fields.17,
            death_date: self._fields.18,
            death_place: self._fields.19,
            description: self._fields.20,
            disambiguating_description: self._fields.21,
            duns: self._fields.22,
            email: self._fields.23,
            family_name: self._fields.24,
            fax_number: self._fields.25,
            follows: self._fields.26,
            funder: self._fields.27,
            funding: self._fields.28,
            gender: self._fields.29,
            given_name: self._fields.30,
            global_location_number: self._fields.31,
            has_certification: self._fields.32,
            has_credential: self._fields.33,
            has_occupation: self._fields.34,
            has_offer_catalog: self._fields.35,
            has_pos: self._fields.36,
            height: self._fields.37,
            home_location: self._fields.38,
            honorific_prefix: self._fields.39,
            honorific_suffix: self._fields.40,
            identifier: self._fields.41,
            image: self._fields.42,
            interaction_statistic: self._fields.43,
            isic_v4: self._fields.44,
            job_title: self._fields.45,
            knows: self._fields.46,
            knows_about: self._fields.47,
            knows_language: self._fields.48,
            main_entity_of_page: self._fields.49,
            makes_offer: self._fields.50,
            member_of: self._fields.51,
            naics: self._fields.52,
            name: self._fields.53,
            nationality: self._fields.54,
            net_worth: self._fields.55,
            owns: self._fields.56,
            parent: self._fields.57,
            parents: self._fields.58,
            performer_in: self._fields.59,
            potential_action: self._fields.60,
            pronouns: self._fields.61,
            publishing_principles: self._fields.62,
            related_to: self._fields.63,
            same_as: self._fields.64,
            seeks: self._fields.65,
            sibling: self._fields.66,
            siblings: self._fields.67,
            skills: self._fields.68,
            sponsor: self._fields.69,
            spouse: self._fields.70,
            subject_of: self._fields.71,
            tax_id: self._fields.72,
            telephone: self._fields.73,
            url: self._fields.74,
            vat_id: self._fields.75,
            weight: self._fields.76,
            work_location: self._fields.77,
            works_for: self._fields.78,
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data.
    pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> Person<S> {
        Person {
            additional_name: self._fields.0,
            additional_type: self._fields.1,
            address: self._fields.2,
            affiliation: self._fields.3,
            agent_interaction_statistic: self._fields.4,
            alternate_name: self._fields.5,
            alumni_of: self._fields.6,
            award: self._fields.7,
            awards: self._fields.8,
            birth_date: self._fields.9,
            birth_place: self._fields.10,
            brand: self._fields.11,
            call_sign: self._fields.12,
            children: self._fields.13,
            colleague: self._fields.14,
            colleagues: self._fields.15,
            contact_point: self._fields.16,
            contact_points: self._fields.17,
            death_date: self._fields.18,
            death_place: self._fields.19,
            description: self._fields.20,
            disambiguating_description: self._fields.21,
            duns: self._fields.22,
            email: self._fields.23,
            family_name: self._fields.24,
            fax_number: self._fields.25,
            follows: self._fields.26,
            funder: self._fields.27,
            funding: self._fields.28,
            gender: self._fields.29,
            given_name: self._fields.30,
            global_location_number: self._fields.31,
            has_certification: self._fields.32,
            has_credential: self._fields.33,
            has_occupation: self._fields.34,
            has_offer_catalog: self._fields.35,
            has_pos: self._fields.36,
            height: self._fields.37,
            home_location: self._fields.38,
            honorific_prefix: self._fields.39,
            honorific_suffix: self._fields.40,
            identifier: self._fields.41,
            image: self._fields.42,
            interaction_statistic: self._fields.43,
            isic_v4: self._fields.44,
            job_title: self._fields.45,
            knows: self._fields.46,
            knows_about: self._fields.47,
            knows_language: self._fields.48,
            main_entity_of_page: self._fields.49,
            makes_offer: self._fields.50,
            member_of: self._fields.51,
            naics: self._fields.52,
            name: self._fields.53,
            nationality: self._fields.54,
            net_worth: self._fields.55,
            owns: self._fields.56,
            parent: self._fields.57,
            parents: self._fields.58,
            performer_in: self._fields.59,
            potential_action: self._fields.60,
            pronouns: self._fields.61,
            publishing_principles: self._fields.62,
            related_to: self._fields.63,
            same_as: self._fields.64,
            seeks: self._fields.65,
            sibling: self._fields.66,
            siblings: self._fields.67,
            skills: self._fields.68,
            sponsor: self._fields.69,
            spouse: self._fields.70,
            subject_of: self._fields.71,
            tax_id: self._fields.72,
            telephone: self._fields.73,
            url: self._fields.74,
            vat_id: self._fields.75,
            weight: self._fields.76,
            work_location: self._fields.77,
            works_for: self._fields.78,
            extra_data: Some(extra_data),
        }
    }
}