// @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;

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

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

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


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

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

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

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


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

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

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


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

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

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

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

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


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

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


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


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


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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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

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


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


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


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


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

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

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

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


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

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

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


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


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

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


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


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


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

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

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

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

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

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

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


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


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

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

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

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


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

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

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


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

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

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

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

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


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

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


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


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


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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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

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


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


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


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


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

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

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

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


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

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

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


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


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

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


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


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


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

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

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

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

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

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

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

/// Typed wrapper for GetRecord response with this collection's record type.

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

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

impl<'a> LexiconSchema for Embedded<'a> {
    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<'de> = PersonGetRecordOutput<'de>;
    type Err<'de> = RecordError<'de>;
}

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

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

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

impl<'a> PersonBuilder<'a, person_state::Empty> {
    /// Create a new builder with all fields unset
    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,
            ),
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `additionalName` field (optional)
    pub fn additional_name(
        mut self,
        value: impl Into<Option<PersonAdditionalName<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `additionalType` field (optional)
    pub fn additional_type(
        mut self,
        value: impl Into<Option<PersonAdditionalType<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `address` field (optional)
    pub fn address(mut self, value: impl Into<Option<PersonAddress<'a>>>) -> 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<'a>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `affiliation` field (optional)
    pub fn affiliation(
        mut self,
        value: impl Into<Option<PersonAffiliation<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `agentInteractionStatistic` field (optional)
    pub fn agent_interaction_statistic(
        mut self,
        value: impl Into<Option<PersonAgentInteractionStatistic<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.4 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `alternateName` field (optional)
    pub fn alternate_name(
        mut self,
        value: impl Into<Option<PersonAlternateName<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.5 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `alumniOf` field (optional)
    pub fn alumni_of(mut self, value: impl Into<Option<PersonAlumniOf<'a>>>) -> 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<'a>>) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `award` field (optional)
    pub fn award(mut self, value: impl Into<Option<PersonAward<'a>>>) -> 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<'a>>) -> Self {
        self._fields.7 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `awards` field (optional)
    pub fn awards(mut self, value: impl Into<Option<PersonAwards<'a>>>) -> 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<'a>>) -> Self {
        self._fields.8 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `birthDate` field (optional)
    pub fn birth_date(mut self, value: impl Into<Option<PersonBirthDate<'a>>>) -> 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<'a>>) -> Self {
        self._fields.9 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `birthPlace` field (optional)
    pub fn birth_place(
        mut self,
        value: impl Into<Option<PersonBirthPlace<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.10 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `brand` field (optional)
    pub fn brand(mut self, value: impl Into<Option<PersonBrand<'a>>>) -> 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<'a>>) -> Self {
        self._fields.11 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `callSign` field (optional)
    pub fn call_sign(mut self, value: impl Into<Option<PersonCallSign<'a>>>) -> 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<'a>>) -> Self {
        self._fields.12 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `children` field (optional)
    pub fn children(mut self, value: impl Into<Option<PersonChildren<'a>>>) -> 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<'a>>) -> Self {
        self._fields.13 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `colleague` field (optional)
    pub fn colleague(mut self, value: impl Into<Option<PersonColleague<'a>>>) -> 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<'a>>) -> Self {
        self._fields.14 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `colleagues` field (optional)
    pub fn colleagues(mut self, value: impl Into<Option<PersonColleagues<'a>>>) -> 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<'a>>) -> Self {
        self._fields.15 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `contactPoint` field (optional)
    pub fn contact_point(
        mut self,
        value: impl Into<Option<PersonContactPoint<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.16 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `contactPoints` field (optional)
    pub fn contact_points(
        mut self,
        value: impl Into<Option<PersonContactPoints<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.17 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `deathDate` field (optional)
    pub fn death_date(mut self, value: impl Into<Option<PersonDeathDate<'a>>>) -> 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<'a>>) -> Self {
        self._fields.18 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `deathPlace` field (optional)
    pub fn death_place(
        mut self,
        value: impl Into<Option<PersonDeathPlace<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.19 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `description` field (optional)
    pub fn description(
        mut self,
        value: impl Into<Option<PersonDescription<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.20 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `disambiguatingDescription` field (optional)
    pub fn disambiguating_description(
        mut self,
        value: impl Into<Option<PersonDisambiguatingDescription<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.21 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `duns` field (optional)
    pub fn duns(mut self, value: impl Into<Option<PersonDuns<'a>>>) -> 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<'a>>) -> Self {
        self._fields.22 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `email` field (optional)
    pub fn email(mut self, value: impl Into<Option<PersonEmail<'a>>>) -> 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<'a>>) -> Self {
        self._fields.23 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `familyName` field (optional)
    pub fn family_name(
        mut self,
        value: impl Into<Option<PersonFamilyName<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.24 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `faxNumber` field (optional)
    pub fn fax_number(mut self, value: impl Into<Option<PersonFaxNumber<'a>>>) -> 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<'a>>) -> Self {
        self._fields.25 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `follows` field (optional)
    pub fn follows(mut self, value: impl Into<Option<PersonFollows<'a>>>) -> 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<'a>>) -> Self {
        self._fields.26 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `funder` field (optional)
    pub fn funder(mut self, value: impl Into<Option<PersonFunder<'a>>>) -> 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<'a>>) -> Self {
        self._fields.27 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `funding` field (optional)
    pub fn funding(mut self, value: impl Into<Option<PersonFunding<'a>>>) -> 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<'a>>) -> Self {
        self._fields.28 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `gender` field (optional)
    pub fn gender(mut self, value: impl Into<Option<PersonGender<'a>>>) -> 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<'a>>) -> Self {
        self._fields.29 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `givenName` field (optional)
    pub fn given_name(mut self, value: impl Into<Option<PersonGivenName<'a>>>) -> 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<'a>>) -> Self {
        self._fields.30 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `globalLocationNumber` field (optional)
    pub fn global_location_number(
        mut self,
        value: impl Into<Option<PersonGlobalLocationNumber<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.31 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `hasCertification` field (optional)
    pub fn has_certification(
        mut self,
        value: impl Into<Option<PersonHasCertification<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.32 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `hasCredential` field (optional)
    pub fn has_credential(
        mut self,
        value: impl Into<Option<PersonHasCredential<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.33 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `hasOccupation` field (optional)
    pub fn has_occupation(
        mut self,
        value: impl Into<Option<PersonHasOccupation<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.34 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `hasOfferCatalog` field (optional)
    pub fn has_offer_catalog(
        mut self,
        value: impl Into<Option<PersonHasOfferCatalog<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.35 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `hasPOS` field (optional)
    pub fn has_pos(mut self, value: impl Into<Option<PersonHasPos<'a>>>) -> 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<'a>>) -> Self {
        self._fields.36 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `height` field (optional)
    pub fn height(mut self, value: impl Into<Option<PersonHeight<'a>>>) -> 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<'a>>) -> Self {
        self._fields.37 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `homeLocation` field (optional)
    pub fn home_location(
        mut self,
        value: impl Into<Option<PersonHomeLocation<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.38 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `honorificPrefix` field (optional)
    pub fn honorific_prefix(
        mut self,
        value: impl Into<Option<PersonHonorificPrefix<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.39 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `honorificSuffix` field (optional)
    pub fn honorific_suffix(
        mut self,
        value: impl Into<Option<PersonHonorificSuffix<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.40 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `identifier` field (optional)
    pub fn identifier(mut self, value: impl Into<Option<PersonIdentifier<'a>>>) -> 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<'a>>) -> Self {
        self._fields.41 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `image` field (optional)
    pub fn image(mut self, value: impl Into<Option<PersonImage<'a>>>) -> 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<'a>>) -> Self {
        self._fields.42 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `interactionStatistic` field (optional)
    pub fn interaction_statistic(
        mut self,
        value: impl Into<Option<PersonInteractionStatistic<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.43 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `isicV4` field (optional)
    pub fn isic_v4(mut self, value: impl Into<Option<PersonIsicV4<'a>>>) -> 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<'a>>) -> Self {
        self._fields.44 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `jobTitle` field (optional)
    pub fn job_title(mut self, value: impl Into<Option<PersonJobTitle<'a>>>) -> 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<'a>>) -> Self {
        self._fields.45 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `knows` field (optional)
    pub fn knows(mut self, value: impl Into<Option<PersonKnows<'a>>>) -> 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<'a>>) -> Self {
        self._fields.46 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `knowsAbout` field (optional)
    pub fn knows_about(
        mut self,
        value: impl Into<Option<PersonKnowsAbout<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.47 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `knowsLanguage` field (optional)
    pub fn knows_language(
        mut self,
        value: impl Into<Option<PersonKnowsLanguage<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.48 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `mainEntityOfPage` field (optional)
    pub fn main_entity_of_page(
        mut self,
        value: impl Into<Option<PersonMainEntityOfPage<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.49 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `makesOffer` field (optional)
    pub fn makes_offer(
        mut self,
        value: impl Into<Option<PersonMakesOffer<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.50 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `memberOf` field (optional)
    pub fn member_of(mut self, value: impl Into<Option<PersonMemberOf<'a>>>) -> 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<'a>>) -> Self {
        self._fields.51 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `naics` field (optional)
    pub fn naics(mut self, value: impl Into<Option<PersonNaics<'a>>>) -> 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<'a>>) -> Self {
        self._fields.52 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `name` field (optional)
    pub fn name(mut self, value: impl Into<Option<PersonName<'a>>>) -> 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<'a>>) -> Self {
        self._fields.53 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `nationality` field (optional)
    pub fn nationality(
        mut self,
        value: impl Into<Option<PersonNationality<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.54 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `netWorth` field (optional)
    pub fn net_worth(mut self, value: impl Into<Option<PersonNetWorth<'a>>>) -> 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<'a>>) -> Self {
        self._fields.55 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `owns` field (optional)
    pub fn owns(mut self, value: impl Into<Option<PersonOwns<'a>>>) -> 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<'a>>) -> Self {
        self._fields.56 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `parent` field (optional)
    pub fn parent(mut self, value: impl Into<Option<PersonParent<'a>>>) -> 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<'a>>) -> Self {
        self._fields.57 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `parents` field (optional)
    pub fn parents(mut self, value: impl Into<Option<PersonParents<'a>>>) -> 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<'a>>) -> Self {
        self._fields.58 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `performerIn` field (optional)
    pub fn performer_in(
        mut self,
        value: impl Into<Option<PersonPerformerIn<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.59 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `potentialAction` field (optional)
    pub fn potential_action(
        mut self,
        value: impl Into<Option<PersonPotentialAction<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.60 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `pronouns` field (optional)
    pub fn pronouns(mut self, value: impl Into<Option<PersonPronouns<'a>>>) -> 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<'a>>) -> Self {
        self._fields.61 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `publishingPrinciples` field (optional)
    pub fn publishing_principles(
        mut self,
        value: impl Into<Option<PersonPublishingPrinciples<'a>>>,
    ) -> 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<'a>>,
    ) -> Self {
        self._fields.62 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `relatedTo` field (optional)
    pub fn related_to(mut self, value: impl Into<Option<PersonRelatedTo<'a>>>) -> 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<'a>>) -> Self {
        self._fields.63 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `sameAs` field (optional)
    pub fn same_as(mut self, value: impl Into<Option<PersonSameAs<'a>>>) -> 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<'a>>) -> Self {
        self._fields.64 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `seeks` field (optional)
    pub fn seeks(mut self, value: impl Into<Option<PersonSeeks<'a>>>) -> 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<'a>>) -> Self {
        self._fields.65 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `sibling` field (optional)
    pub fn sibling(mut self, value: impl Into<Option<PersonSibling<'a>>>) -> 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<'a>>) -> Self {
        self._fields.66 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `siblings` field (optional)
    pub fn siblings(mut self, value: impl Into<Option<PersonSiblings<'a>>>) -> 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<'a>>) -> Self {
        self._fields.67 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `skills` field (optional)
    pub fn skills(mut self, value: impl Into<Option<PersonSkills<'a>>>) -> 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<'a>>) -> Self {
        self._fields.68 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `sponsor` field (optional)
    pub fn sponsor(mut self, value: impl Into<Option<PersonSponsor<'a>>>) -> 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<'a>>) -> Self {
        self._fields.69 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `spouse` field (optional)
    pub fn spouse(mut self, value: impl Into<Option<PersonSpouse<'a>>>) -> 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<'a>>) -> Self {
        self._fields.70 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `subjectOf` field (optional)
    pub fn subject_of(mut self, value: impl Into<Option<PersonSubjectOf<'a>>>) -> 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<'a>>) -> Self {
        self._fields.71 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `taxID` field (optional)
    pub fn tax_id(mut self, value: impl Into<Option<PersonTaxId<'a>>>) -> 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<'a>>) -> Self {
        self._fields.72 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `telephone` field (optional)
    pub fn telephone(mut self, value: impl Into<Option<PersonTelephone<'a>>>) -> 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<'a>>) -> Self {
        self._fields.73 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `url` field (optional)
    pub fn url(mut self, value: impl Into<Option<PersonUrl<'a>>>) -> 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<'a>>) -> Self {
        self._fields.74 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `vatID` field (optional)
    pub fn vat_id(mut self, value: impl Into<Option<PersonVatId<'a>>>) -> 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<'a>>) -> Self {
        self._fields.75 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `weight` field (optional)
    pub fn weight(mut self, value: impl Into<Option<PersonWeight<'a>>>) -> 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<'a>>) -> Self {
        self._fields.76 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `workLocation` field (optional)
    pub fn work_location(
        mut self,
        value: impl Into<Option<PersonWorkLocation<'a>>>,
    ) -> 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<'a>>) -> Self {
        self._fields.77 = value;
        self
    }
}

impl<'a, S: person_state::State> PersonBuilder<'a, S> {
    /// Set the `worksFor` field (optional)
    pub fn works_for(mut self, value: impl Into<Option<PersonWorksFor<'a>>>) -> 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<'a>>) -> Self {
        self._fields.78 = value;
        self
    }
}

impl<'a, S> PersonBuilder<'a, S>
where
    S: person_state::State,
{
    /// Build the final struct
    pub fn build(self) -> Person<'a> {
        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<jacquard_common::deps::smol_str::SmolStr, Data<'a>>,
    ) -> Person<'a> {
        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),
        }
    }
}