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

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

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

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

#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Serialize, Deserialize};
use crate::social_flockfeeds::lexical::r#type::article;
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 musical group, such as a band, an orchestra, or a choir. Can also be a solo musician.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct Embedded<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accepted_payment_method: Option<EmbeddedAcceptedPaymentMethod<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub actionable_feedback_policy: Option<EmbeddedActionableFeedbackPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_type: Option<EmbeddedAdditionalType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<EmbeddedAddress<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_interaction_statistic: Option<EmbeddedAgentInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aggregate_rating: Option<EmbeddedAggregateRating<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub album: Option<EmbeddedAlbum<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub albums: Option<EmbeddedAlbums<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternate_name: Option<EmbeddedAlternateName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alumni: Option<EmbeddedAlumni<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub area_served: Option<EmbeddedAreaServed<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub award: Option<EmbeddedAward<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awards: Option<EmbeddedAwards<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub brand: Option<EmbeddedBrand<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub company_registration: Option<EmbeddedCompanyRegistration<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact_point: Option<EmbeddedContactPoint<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact_points: Option<EmbeddedContactPoints<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub corrections_policy: Option<EmbeddedCorrectionsPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub department: Option<EmbeddedDepartment<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<EmbeddedDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disambiguating_description: Option<EmbeddedDisambiguatingDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dissolution_date: Option<EmbeddedDissolutionDate<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub diversity_policy: Option<EmbeddedDiversityPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub diversity_staffing_report: Option<EmbeddedDiversityStaffingReport<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duns: Option<EmbeddedDuns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<EmbeddedEmail<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub employee: Option<EmbeddedEmployee<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub employees: Option<EmbeddedEmployees<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ethics_policy: Option<EmbeddedEthicsPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event: Option<EmbeddedEvent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub events: Option<EmbeddedEvents<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fax_number: Option<EmbeddedFaxNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founder: Option<EmbeddedFounder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founders: Option<EmbeddedFounders<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founding_date: Option<EmbeddedFoundingDate<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founding_location: Option<EmbeddedFoundingLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funder: Option<EmbeddedFunder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funding: Option<EmbeddedFunding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub genre: Option<EmbeddedGenre<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub global_location_number: Option<EmbeddedGlobalLocationNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_certification: Option<EmbeddedHasCertification<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_credential: Option<EmbeddedHasCredential<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_gs1_digital_link: Option<EmbeddedHasGs1DigitalLink<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_member_program: Option<EmbeddedHasMemberProgram<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_merchant_return_policy: Option<EmbeddedHasMerchantReturnPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_offer_catalog: Option<EmbeddedHasOfferCatalog<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_pos: Option<EmbeddedHasPos<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_product_return_policy: Option<EmbeddedHasProductReturnPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_shipping_service: Option<EmbeddedHasShippingService<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifier: Option<EmbeddedIdentifier<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<EmbeddedImage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interaction_statistic: Option<EmbeddedInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isic_v4: Option<EmbeddedIsicV4<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub iso6523_code: Option<EmbeddedIso6523Code<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub keywords: Option<EmbeddedKeywords<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows_about: Option<EmbeddedKnowsAbout<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows_language: Option<EmbeddedKnowsLanguage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub legal_address: Option<EmbeddedLegalAddress<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub legal_name: Option<EmbeddedLegalName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub legal_representative: Option<EmbeddedLegalRepresentative<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lei_code: Option<EmbeddedLeiCode<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location: Option<EmbeddedLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub logo: Option<EmbeddedLogo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity_of_page: Option<EmbeddedMainEntityOfPage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub makes_offer: Option<EmbeddedMakesOffer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<EmbeddedMember<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_of: Option<EmbeddedMemberOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<EmbeddedMembers<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_group_member: Option<EmbeddedMusicGroupMember<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub naics: Option<EmbeddedNaics<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<EmbeddedName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nonprofit_status: Option<EmbeddedNonprofitStatus<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number_of_employees: Option<EmbeddedNumberOfEmployees<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ownership_funding_info: Option<EmbeddedOwnershipFundingInfo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub owns: Option<EmbeddedOwns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent_organization: Option<EmbeddedParentOrganization<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub potential_action: Option<EmbeddedPotentialAction<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publishing_principles: Option<EmbeddedPublishingPrinciples<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub review: Option<EmbeddedReview<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reviews: Option<EmbeddedReviews<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub same_as: Option<EmbeddedSameAs<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seeks: Option<EmbeddedSeeks<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_area: Option<EmbeddedServiceArea<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub skills: Option<EmbeddedSkills<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slogan: Option<EmbeddedSlogan<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sponsor: Option<EmbeddedSponsor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sub_organization: Option<EmbeddedSubOrganization<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject_of: Option<EmbeddedSubjectOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tax_id: Option<EmbeddedTaxId<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telephone: Option<EmbeddedTelephone<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub track: Option<EmbeddedTrack<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tracks: Option<EmbeddedTracks<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unnamed_sources_policy: Option<EmbeddedUnnamedSourcesPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<EmbeddedUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vat_id: Option<EmbeddedVatId<S>>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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


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


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

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


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


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

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


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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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


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


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


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


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


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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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


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


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


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

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

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

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

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

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

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

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(
    rename_all = "camelCase",
    rename = "social.flockfeeds.lexical.type.MusicGroup",
    tag = "$type",
    bound(deserialize = "S: Deserialize<'de> + BosStr")
)]
pub struct MusicGroup<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub accepted_payment_method: Option<MusicGroupAcceptedPaymentMethod<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub actionable_feedback_policy: Option<MusicGroupActionableFeedbackPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_type: Option<MusicGroupAdditionalType<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<MusicGroupAddress<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_interaction_statistic: Option<MusicGroupAgentInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aggregate_rating: Option<MusicGroupAggregateRating<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub album: Option<MusicGroupAlbum<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub albums: Option<MusicGroupAlbums<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alternate_name: Option<MusicGroupAlternateName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alumni: Option<MusicGroupAlumni<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub area_served: Option<MusicGroupAreaServed<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub award: Option<MusicGroupAward<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awards: Option<MusicGroupAwards<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub brand: Option<MusicGroupBrand<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub company_registration: Option<MusicGroupCompanyRegistration<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact_point: Option<MusicGroupContactPoint<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact_points: Option<MusicGroupContactPoints<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub corrections_policy: Option<MusicGroupCorrectionsPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub department: Option<MusicGroupDepartment<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<MusicGroupDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disambiguating_description: Option<MusicGroupDisambiguatingDescription<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dissolution_date: Option<MusicGroupDissolutionDate<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub diversity_policy: Option<MusicGroupDiversityPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub diversity_staffing_report: Option<MusicGroupDiversityStaffingReport<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duns: Option<MusicGroupDuns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<MusicGroupEmail<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub employee: Option<MusicGroupEmployee<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub employees: Option<MusicGroupEmployees<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ethics_policy: Option<MusicGroupEthicsPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event: Option<MusicGroupEvent<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub events: Option<MusicGroupEvents<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fax_number: Option<MusicGroupFaxNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founder: Option<MusicGroupFounder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founders: Option<MusicGroupFounders<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founding_date: Option<MusicGroupFoundingDate<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founding_location: Option<MusicGroupFoundingLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funder: Option<MusicGroupFunder<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub funding: Option<MusicGroupFunding<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub genre: Option<MusicGroupGenre<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub global_location_number: Option<MusicGroupGlobalLocationNumber<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_certification: Option<MusicGroupHasCertification<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_credential: Option<MusicGroupHasCredential<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_gs1_digital_link: Option<MusicGroupHasGs1DigitalLink<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_member_program: Option<MusicGroupHasMemberProgram<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_merchant_return_policy: Option<MusicGroupHasMerchantReturnPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_offer_catalog: Option<MusicGroupHasOfferCatalog<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_pos: Option<MusicGroupHasPos<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_product_return_policy: Option<MusicGroupHasProductReturnPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_shipping_service: Option<MusicGroupHasShippingService<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifier: Option<MusicGroupIdentifier<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<MusicGroupImage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interaction_statistic: Option<MusicGroupInteractionStatistic<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isic_v4: Option<MusicGroupIsicV4<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub iso6523_code: Option<MusicGroupIso6523Code<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub keywords: Option<MusicGroupKeywords<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows_about: Option<MusicGroupKnowsAbout<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knows_language: Option<MusicGroupKnowsLanguage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub legal_address: Option<MusicGroupLegalAddress<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub legal_name: Option<MusicGroupLegalName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub legal_representative: Option<MusicGroupLegalRepresentative<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lei_code: Option<MusicGroupLeiCode<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location: Option<MusicGroupLocation<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub logo: Option<MusicGroupLogo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_entity_of_page: Option<MusicGroupMainEntityOfPage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub makes_offer: Option<MusicGroupMakesOffer<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<MusicGroupMember<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_of: Option<MusicGroupMemberOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<MusicGroupMembers<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_group_member: Option<MusicGroupMusicGroupMember<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub naics: Option<MusicGroupNaics<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<MusicGroupName<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nonprofit_status: Option<MusicGroupNonprofitStatus<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number_of_employees: Option<MusicGroupNumberOfEmployees<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ownership_funding_info: Option<MusicGroupOwnershipFundingInfo<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub owns: Option<MusicGroupOwns<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent_organization: Option<MusicGroupParentOrganization<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub potential_action: Option<MusicGroupPotentialAction<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publishing_principles: Option<MusicGroupPublishingPrinciples<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub review: Option<MusicGroupReview<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reviews: Option<MusicGroupReviews<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub same_as: Option<MusicGroupSameAs<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seeks: Option<MusicGroupSeeks<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_area: Option<MusicGroupServiceArea<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub skills: Option<MusicGroupSkills<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slogan: Option<MusicGroupSlogan<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sponsor: Option<MusicGroupSponsor<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sub_organization: Option<MusicGroupSubOrganization<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subject_of: Option<MusicGroupSubjectOf<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tax_id: Option<MusicGroupTaxId<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telephone: Option<MusicGroupTelephone<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub track: Option<MusicGroupTrack<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tracks: Option<MusicGroupTracks<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unnamed_sources_policy: Option<MusicGroupUnnamedSourcesPolicy<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<MusicGroupUrl<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vat_id: Option<MusicGroupVatId<S>>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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


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


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

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


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


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

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


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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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


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


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


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


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


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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn lexicon_doc_social_flockfeeds_lexical_type_MusicGroup() -> 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.MusicGroup"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("embedded"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "A musical group, such as a band, an orchestra, or a choir. Can also be a solo musician.",
                        ),
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("acceptedPaymentMethod"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.LoanOrCredit#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.PaymentMethod#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#acceptedPaymentMethodScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#acceptedPaymentMethodList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("actionableFeedbackPolicy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#actionableFeedbackPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#actionableFeedbackPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("additionalType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#additionalTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#addressScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#addressList")
                                ],
                                ..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.musicGroup#agentInteractionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("aggregateRating"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.AggregateRating#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#aggregateRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("album"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MusicAlbum#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#albumList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("albums"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MusicAlbum#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#albumsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternateName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#alternateNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#alternateNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alumni"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#alumniList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("areaServed"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.AdministrativeArea#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeoShape#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#areaServedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#areaServedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("award"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#awardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#awardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("awards"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#awardsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#awardsList")
                                ],
                                ..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.musicGroup#brandList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("companyRegistration"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Certification#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#companyRegistrationList")
                                ],
                                ..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.musicGroup#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.musicGroup#contactPointsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("correctionsPolicy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#correctionsPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#correctionsPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("department"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#departmentList")
                                ],
                                ..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.musicGroup#descriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#descriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("disambiguatingDescription"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#disambiguatingDescriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#disambiguatingDescriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dissolutionDate"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#dissolutionDateScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#dissolutionDateList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("diversityPolicy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#diversityPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#diversityPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("diversityStaffingReport"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Article#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#diversityStaffingReportScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#diversityStaffingReportList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("duns"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#dunsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#dunsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("email"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#emailScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#emailList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("employee"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#employeeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("employees"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#employeesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("ethicsPolicy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#ethicsPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#ethicsPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("event"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#eventList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("events"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#eventsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("faxNumber"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#faxNumberScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#faxNumberList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("founder"),
                            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.musicGroup#founderList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("founders"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#foundersList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("foundingDate"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#foundingDateScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#foundingDateList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("foundingLocation"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#foundingLocationList")
                                ],
                                ..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.musicGroup#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.musicGroup#fundingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("genre"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#genreScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#genreList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("globalLocationNumber"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#globalLocationNumberScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#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.musicGroup#hasCredentialList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasGS1DigitalLink"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasGS1DigitalLinkScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasGS1DigitalLinkList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasMemberProgram"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MemberProgram#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasMemberProgramList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasMerchantReturnPolicy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MerchantReturnPolicy#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasMerchantReturnPolicyList")
                                ],
                                ..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.musicGroup#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.musicGroup#hasPOSList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasProductReturnPolicy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ProductReturnPolicy#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasProductReturnPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasShippingService"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ShippingService#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasShippingServiceList")
                                ],
                                ..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.musicGroup#identifierScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#imageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#interactionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isicV4"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#isicV4Scalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#isicV4List")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("iso6523Code"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#iso6523CodeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#iso6523CodeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("keywords"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#keywordsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#keywordsList")
                                ],
                                ..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.musicGroup#knowsAboutScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#knowsLanguageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#knowsLanguageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("legalAddress"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PostalAddress#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#legalAddressList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("legalName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#legalNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#legalNameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("legalRepresentative"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#legalRepresentativeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("leiCode"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#leiCodeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#leiCodeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("location"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.PostalAddress#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.VirtualLocation#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#locationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#locationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("logo"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#logoScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#logoList")
                                ],
                                ..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.musicGroup#mainEntityOfPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#makesOfferList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("member"),
                            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.musicGroup#memberList")
                                ],
                                ..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.musicGroup#memberOfList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("members"),
                            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.musicGroup#membersList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("musicGroupMember"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#musicGroupMemberList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("naics"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#naicsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#naicsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#nameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#nameList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("nonprofitStatus"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.NonprofitType#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#nonprofitStatusScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#nonprofitStatusList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("numberOfEmployees"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#numberOfEmployeesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("ownershipFundingInfo"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.AboutPage#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#ownershipFundingInfoScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#ownershipFundingInfoList")
                                ],
                                ..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.musicGroup#ownsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("parentOrganization"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#parentOrganizationList")
                                ],
                                ..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.musicGroup#potentialActionList")
                                ],
                                ..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.musicGroup#publishingPrinciplesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#publishingPrinciplesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("review"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Review#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#reviewList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("reviews"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Review#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#reviewsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sameAs"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#sameAsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#seeksList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("serviceArea"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.AdministrativeArea#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeoShape#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#serviceAreaList")
                                ],
                                ..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.musicGroup#skillsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#skillsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("slogan"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#sloganScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#sloganList")
                                ],
                                ..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.musicGroup#sponsorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("subOrganization"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#subOrganizationList")
                                ],
                                ..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.musicGroup#subjectOfList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("taxID"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#taxIDScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#taxIDList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("telephone"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#telephoneScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#telephoneList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("track"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.MusicRecording#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#trackList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("tracks"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.MusicRecording#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#tracksList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("unnamedSourcesPolicy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#unnamedSourcesPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#unnamedSourcesPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("url"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#urlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#urlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("vatID"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#vatIDScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#vatIDList")
                                ],
                                ..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 musical group, such as a band, an orchestra, or a choir. Can also be a solo musician.",
                            ),
                        ),
                        properties: {
                            #[allow(unused_mut)]
                            let mut map = BTreeMap::new();
                            map.insert(
                                SmolStr::new_static("acceptedPaymentMethod"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.LoanOrCredit#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.PaymentMethod#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#acceptedPaymentMethodScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#acceptedPaymentMethodList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("actionableFeedbackPolicy"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#actionableFeedbackPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#actionableFeedbackPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("additionalType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#additionalTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#addressScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#addressList")
                                    ],
                                    ..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.musicGroup#agentInteractionStatisticList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("aggregateRating"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.AggregateRating#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#aggregateRatingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("album"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MusicAlbum#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#albumList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("albums"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MusicAlbum#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#albumsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alternateName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#alternateNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#alternateNameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alumni"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#alumniList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("areaServed"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.AdministrativeArea#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeoShape#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#areaServedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#areaServedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("award"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#awardScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#awardList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("awards"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#awardsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#awardsList")
                                    ],
                                    ..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.musicGroup#brandList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("companyRegistration"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Certification#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#companyRegistrationList")
                                    ],
                                    ..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.musicGroup#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.musicGroup#contactPointsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("correctionsPolicy"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#correctionsPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#correctionsPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("department"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#departmentList")
                                    ],
                                    ..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.musicGroup#descriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#descriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("disambiguatingDescription"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#disambiguatingDescriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#disambiguatingDescriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("dissolutionDate"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#dissolutionDateScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#dissolutionDateList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("diversityPolicy"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#diversityPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#diversityPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("diversityStaffingReport"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Article#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#diversityStaffingReportScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#diversityStaffingReportList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("duns"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#dunsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#dunsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("email"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#emailScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#emailList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("employee"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#employeeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("employees"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#employeesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("ethicsPolicy"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#ethicsPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#ethicsPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("event"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#eventList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("events"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Event#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#eventsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("faxNumber"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#faxNumberScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#faxNumberList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("founder"),
                                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.musicGroup#founderList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("founders"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#foundersList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("foundingDate"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#foundingDateScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#foundingDateList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("foundingLocation"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#foundingLocationList")
                                    ],
                                    ..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.musicGroup#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.musicGroup#fundingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("genre"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#genreScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#genreList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("globalLocationNumber"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#globalLocationNumberScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#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.musicGroup#hasCredentialList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasGS1DigitalLink"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasGS1DigitalLinkScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasGS1DigitalLinkList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasMemberProgram"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MemberProgram#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasMemberProgramList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasMerchantReturnPolicy"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MerchantReturnPolicy#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasMerchantReturnPolicyList")
                                    ],
                                    ..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.musicGroup#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.musicGroup#hasPOSList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasProductReturnPolicy"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ProductReturnPolicy#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasProductReturnPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasShippingService"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ShippingService#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#hasShippingServiceList")
                                    ],
                                    ..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.musicGroup#identifierScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#imageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#interactionStatisticList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isicV4"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#isicV4Scalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#isicV4List")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("iso6523Code"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#iso6523CodeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#iso6523CodeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("keywords"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.DefinedTerm#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#keywordsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#keywordsList")
                                    ],
                                    ..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.musicGroup#knowsAboutScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#knowsLanguageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#knowsLanguageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("legalAddress"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.PostalAddress#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#legalAddressList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("legalName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#legalNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#legalNameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("legalRepresentative"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#legalRepresentativeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("leiCode"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#leiCodeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#leiCodeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("location"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.PostalAddress#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.VirtualLocation#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#locationScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#locationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("logo"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#logoScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#logoList")
                                    ],
                                    ..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.musicGroup#mainEntityOfPageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#makesOfferList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("member"),
                                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.musicGroup#memberList")
                                    ],
                                    ..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.musicGroup#memberOfList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("members"),
                                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.musicGroup#membersList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("musicGroupMember"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Person#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#musicGroupMemberList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("naics"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#naicsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#naicsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("name"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#nameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#nameList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("nonprofitStatus"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.NonprofitType#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#nonprofitStatusScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#nonprofitStatusList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("numberOfEmployees"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#numberOfEmployeesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("ownershipFundingInfo"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.AboutPage#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#ownershipFundingInfoScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#ownershipFundingInfoList")
                                    ],
                                    ..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.musicGroup#ownsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("parentOrganization"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#parentOrganizationList")
                                    ],
                                    ..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.musicGroup#potentialActionList")
                                    ],
                                    ..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.musicGroup#publishingPrinciplesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#publishingPrinciplesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("review"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Review#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#reviewList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("reviews"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Review#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#reviewsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sameAs"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#sameAsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#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.musicGroup#seeksList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("serviceArea"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.AdministrativeArea#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeoShape#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#serviceAreaList")
                                    ],
                                    ..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.musicGroup#skillsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#skillsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("slogan"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#sloganScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#sloganList")
                                    ],
                                    ..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.musicGroup#sponsorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("subOrganization"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#subOrganizationList")
                                    ],
                                    ..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.musicGroup#subjectOfList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("taxID"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#taxIDScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#taxIDList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("telephone"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#telephoneScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#telephoneList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("track"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ItemList#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.MusicRecording#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#trackList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("tracks"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.MusicRecording#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#tracksList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("unnamedSourcesPolicy"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.CreativeWork#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#unnamedSourcesPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#unnamedSourcesPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("url"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#urlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#urlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("vatID"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#vatIDScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.musicGroup#vatIDList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map
                        },
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}

pub mod music_group_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 MusicGroupBuilder<St: music_group_state::State, S: BosStr = DefaultStr> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<MusicGroupAcceptedPaymentMethod<S>>,
        Option<MusicGroupActionableFeedbackPolicy<S>>,
        Option<MusicGroupAdditionalType<S>>,
        Option<MusicGroupAddress<S>>,
        Option<MusicGroupAgentInteractionStatistic<S>>,
        Option<MusicGroupAggregateRating<S>>,
        Option<MusicGroupAlbum<S>>,
        Option<MusicGroupAlbums<S>>,
        Option<MusicGroupAlternateName<S>>,
        Option<MusicGroupAlumni<S>>,
        Option<MusicGroupAreaServed<S>>,
        Option<MusicGroupAward<S>>,
        Option<MusicGroupAwards<S>>,
        Option<MusicGroupBrand<S>>,
        Option<MusicGroupCompanyRegistration<S>>,
        Option<MusicGroupContactPoint<S>>,
        Option<MusicGroupContactPoints<S>>,
        Option<MusicGroupCorrectionsPolicy<S>>,
        Option<MusicGroupDepartment<S>>,
        Option<MusicGroupDescription<S>>,
        Option<MusicGroupDisambiguatingDescription<S>>,
        Option<MusicGroupDissolutionDate<S>>,
        Option<MusicGroupDiversityPolicy<S>>,
        Option<MusicGroupDiversityStaffingReport<S>>,
        Option<MusicGroupDuns<S>>,
        Option<MusicGroupEmail<S>>,
        Option<MusicGroupEmployee<S>>,
        Option<MusicGroupEmployees<S>>,
        Option<MusicGroupEthicsPolicy<S>>,
        Option<MusicGroupEvent<S>>,
        Option<MusicGroupEvents<S>>,
        Option<MusicGroupFaxNumber<S>>,
        Option<MusicGroupFounder<S>>,
        Option<MusicGroupFounders<S>>,
        Option<MusicGroupFoundingDate<S>>,
        Option<MusicGroupFoundingLocation<S>>,
        Option<MusicGroupFunder<S>>,
        Option<MusicGroupFunding<S>>,
        Option<MusicGroupGenre<S>>,
        Option<MusicGroupGlobalLocationNumber<S>>,
        Option<MusicGroupHasCertification<S>>,
        Option<MusicGroupHasCredential<S>>,
        Option<MusicGroupHasGs1DigitalLink<S>>,
        Option<MusicGroupHasMemberProgram<S>>,
        Option<MusicGroupHasMerchantReturnPolicy<S>>,
        Option<MusicGroupHasOfferCatalog<S>>,
        Option<MusicGroupHasPos<S>>,
        Option<MusicGroupHasProductReturnPolicy<S>>,
        Option<MusicGroupHasShippingService<S>>,
        Option<MusicGroupIdentifier<S>>,
        Option<MusicGroupImage<S>>,
        Option<MusicGroupInteractionStatistic<S>>,
        Option<MusicGroupIsicV4<S>>,
        Option<MusicGroupIso6523Code<S>>,
        Option<MusicGroupKeywords<S>>,
        Option<MusicGroupKnowsAbout<S>>,
        Option<MusicGroupKnowsLanguage<S>>,
        Option<MusicGroupLegalAddress<S>>,
        Option<MusicGroupLegalName<S>>,
        Option<MusicGroupLegalRepresentative<S>>,
        Option<MusicGroupLeiCode<S>>,
        Option<MusicGroupLocation<S>>,
        Option<MusicGroupLogo<S>>,
        Option<MusicGroupMainEntityOfPage<S>>,
        Option<MusicGroupMakesOffer<S>>,
        Option<MusicGroupMember<S>>,
        Option<MusicGroupMemberOf<S>>,
        Option<MusicGroupMembers<S>>,
        Option<MusicGroupMusicGroupMember<S>>,
        Option<MusicGroupNaics<S>>,
        Option<MusicGroupName<S>>,
        Option<MusicGroupNonprofitStatus<S>>,
        Option<MusicGroupNumberOfEmployees<S>>,
        Option<MusicGroupOwnershipFundingInfo<S>>,
        Option<MusicGroupOwns<S>>,
        Option<MusicGroupParentOrganization<S>>,
        Option<MusicGroupPotentialAction<S>>,
        Option<MusicGroupPublishingPrinciples<S>>,
        Option<MusicGroupReview<S>>,
        Option<MusicGroupReviews<S>>,
        Option<MusicGroupSameAs<S>>,
        Option<MusicGroupSeeks<S>>,
        Option<MusicGroupServiceArea<S>>,
        Option<MusicGroupSkills<S>>,
        Option<MusicGroupSlogan<S>>,
        Option<MusicGroupSponsor<S>>,
        Option<MusicGroupSubOrganization<S>>,
        Option<MusicGroupSubjectOf<S>>,
        Option<MusicGroupTaxId<S>>,
        Option<MusicGroupTelephone<S>>,
        Option<MusicGroupTrack<S>>,
        Option<MusicGroupTracks<S>>,
        Option<MusicGroupUnnamedSourcesPolicy<S>>,
        Option<MusicGroupUrl<S>>,
        Option<MusicGroupVatId<S>>,
    ),
    _type: PhantomData<fn() -> S>,
}

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

impl<S: BosStr> MusicGroup<S> {
    /// Create a new builder for this type
    pub fn builder() -> MusicGroupBuilder<music_group_state::Empty, S> {
        MusicGroupBuilder::builder()
    }
}

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `acceptedPaymentMethod` field (optional)
    pub fn accepted_payment_method(
        mut self,
        value: impl Into<Option<MusicGroupAcceptedPaymentMethod<S>>>,
    ) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `acceptedPaymentMethod` field to an Option value (optional)
    pub fn maybe_accepted_payment_method(
        mut self,
        value: Option<MusicGroupAcceptedPaymentMethod<S>>,
    ) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `actionableFeedbackPolicy` field (optional)
    pub fn actionable_feedback_policy(
        mut self,
        value: impl Into<Option<MusicGroupActionableFeedbackPolicy<S>>>,
    ) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `actionableFeedbackPolicy` field to an Option value (optional)
    pub fn maybe_actionable_feedback_policy(
        mut self,
        value: Option<MusicGroupActionableFeedbackPolicy<S>>,
    ) -> Self {
        self._fields.1 = value;
        self
    }
}

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

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

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `album` field (optional)
    pub fn album(mut self, value: impl Into<Option<MusicGroupAlbum<S>>>) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `album` field to an Option value (optional)
    pub fn maybe_album(mut self, value: Option<MusicGroupAlbum<S>>) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `albums` field (optional)
    pub fn albums(mut self, value: impl Into<Option<MusicGroupAlbums<S>>>) -> Self {
        self._fields.7 = value.into();
        self
    }
    /// Set the `albums` field to an Option value (optional)
    pub fn maybe_albums(mut self, value: Option<MusicGroupAlbums<S>>) -> Self {
        self._fields.7 = value;
        self
    }
}

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `alumni` field (optional)
    pub fn alumni(mut self, value: impl Into<Option<MusicGroupAlumni<S>>>) -> Self {
        self._fields.9 = value.into();
        self
    }
    /// Set the `alumni` field to an Option value (optional)
    pub fn maybe_alumni(mut self, value: Option<MusicGroupAlumni<S>>) -> Self {
        self._fields.9 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `areaServed` field (optional)
    pub fn area_served(
        mut self,
        value: impl Into<Option<MusicGroupAreaServed<S>>>,
    ) -> Self {
        self._fields.10 = value.into();
        self
    }
    /// Set the `areaServed` field to an Option value (optional)
    pub fn maybe_area_served(mut self, value: Option<MusicGroupAreaServed<S>>) -> Self {
        self._fields.10 = value;
        self
    }
}

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

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `companyRegistration` field (optional)
    pub fn company_registration(
        mut self,
        value: impl Into<Option<MusicGroupCompanyRegistration<S>>>,
    ) -> Self {
        self._fields.14 = value.into();
        self
    }
    /// Set the `companyRegistration` field to an Option value (optional)
    pub fn maybe_company_registration(
        mut self,
        value: Option<MusicGroupCompanyRegistration<S>>,
    ) -> Self {
        self._fields.14 = value;
        self
    }
}

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `correctionsPolicy` field (optional)
    pub fn corrections_policy(
        mut self,
        value: impl Into<Option<MusicGroupCorrectionsPolicy<S>>>,
    ) -> Self {
        self._fields.17 = value.into();
        self
    }
    /// Set the `correctionsPolicy` field to an Option value (optional)
    pub fn maybe_corrections_policy(
        mut self,
        value: Option<MusicGroupCorrectionsPolicy<S>>,
    ) -> Self {
        self._fields.17 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `department` field (optional)
    pub fn department(
        mut self,
        value: impl Into<Option<MusicGroupDepartment<S>>>,
    ) -> Self {
        self._fields.18 = value.into();
        self
    }
    /// Set the `department` field to an Option value (optional)
    pub fn maybe_department(mut self, value: Option<MusicGroupDepartment<S>>) -> Self {
        self._fields.18 = value;
        self
    }
}

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `dissolutionDate` field (optional)
    pub fn dissolution_date(
        mut self,
        value: impl Into<Option<MusicGroupDissolutionDate<S>>>,
    ) -> Self {
        self._fields.21 = value.into();
        self
    }
    /// Set the `dissolutionDate` field to an Option value (optional)
    pub fn maybe_dissolution_date(
        mut self,
        value: Option<MusicGroupDissolutionDate<S>>,
    ) -> Self {
        self._fields.21 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `diversityPolicy` field (optional)
    pub fn diversity_policy(
        mut self,
        value: impl Into<Option<MusicGroupDiversityPolicy<S>>>,
    ) -> Self {
        self._fields.22 = value.into();
        self
    }
    /// Set the `diversityPolicy` field to an Option value (optional)
    pub fn maybe_diversity_policy(
        mut self,
        value: Option<MusicGroupDiversityPolicy<S>>,
    ) -> Self {
        self._fields.22 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `diversityStaffingReport` field (optional)
    pub fn diversity_staffing_report(
        mut self,
        value: impl Into<Option<MusicGroupDiversityStaffingReport<S>>>,
    ) -> Self {
        self._fields.23 = value.into();
        self
    }
    /// Set the `diversityStaffingReport` field to an Option value (optional)
    pub fn maybe_diversity_staffing_report(
        mut self,
        value: Option<MusicGroupDiversityStaffingReport<S>>,
    ) -> Self {
        self._fields.23 = value;
        self
    }
}

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `employee` field (optional)
    pub fn employee(mut self, value: impl Into<Option<MusicGroupEmployee<S>>>) -> Self {
        self._fields.26 = value.into();
        self
    }
    /// Set the `employee` field to an Option value (optional)
    pub fn maybe_employee(mut self, value: Option<MusicGroupEmployee<S>>) -> Self {
        self._fields.26 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `employees` field (optional)
    pub fn employees(
        mut self,
        value: impl Into<Option<MusicGroupEmployees<S>>>,
    ) -> Self {
        self._fields.27 = value.into();
        self
    }
    /// Set the `employees` field to an Option value (optional)
    pub fn maybe_employees(mut self, value: Option<MusicGroupEmployees<S>>) -> Self {
        self._fields.27 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `ethicsPolicy` field (optional)
    pub fn ethics_policy(
        mut self,
        value: impl Into<Option<MusicGroupEthicsPolicy<S>>>,
    ) -> Self {
        self._fields.28 = value.into();
        self
    }
    /// Set the `ethicsPolicy` field to an Option value (optional)
    pub fn maybe_ethics_policy(
        mut self,
        value: Option<MusicGroupEthicsPolicy<S>>,
    ) -> Self {
        self._fields.28 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `event` field (optional)
    pub fn event(mut self, value: impl Into<Option<MusicGroupEvent<S>>>) -> Self {
        self._fields.29 = value.into();
        self
    }
    /// Set the `event` field to an Option value (optional)
    pub fn maybe_event(mut self, value: Option<MusicGroupEvent<S>>) -> Self {
        self._fields.29 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `events` field (optional)
    pub fn events(mut self, value: impl Into<Option<MusicGroupEvents<S>>>) -> Self {
        self._fields.30 = value.into();
        self
    }
    /// Set the `events` field to an Option value (optional)
    pub fn maybe_events(mut self, value: Option<MusicGroupEvents<S>>) -> Self {
        self._fields.30 = value;
        self
    }
}

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `founder` field (optional)
    pub fn founder(mut self, value: impl Into<Option<MusicGroupFounder<S>>>) -> Self {
        self._fields.32 = value.into();
        self
    }
    /// Set the `founder` field to an Option value (optional)
    pub fn maybe_founder(mut self, value: Option<MusicGroupFounder<S>>) -> Self {
        self._fields.32 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `founders` field (optional)
    pub fn founders(mut self, value: impl Into<Option<MusicGroupFounders<S>>>) -> Self {
        self._fields.33 = value.into();
        self
    }
    /// Set the `founders` field to an Option value (optional)
    pub fn maybe_founders(mut self, value: Option<MusicGroupFounders<S>>) -> Self {
        self._fields.33 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `foundingDate` field (optional)
    pub fn founding_date(
        mut self,
        value: impl Into<Option<MusicGroupFoundingDate<S>>>,
    ) -> Self {
        self._fields.34 = value.into();
        self
    }
    /// Set the `foundingDate` field to an Option value (optional)
    pub fn maybe_founding_date(
        mut self,
        value: Option<MusicGroupFoundingDate<S>>,
    ) -> Self {
        self._fields.34 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `foundingLocation` field (optional)
    pub fn founding_location(
        mut self,
        value: impl Into<Option<MusicGroupFoundingLocation<S>>>,
    ) -> Self {
        self._fields.35 = value.into();
        self
    }
    /// Set the `foundingLocation` field to an Option value (optional)
    pub fn maybe_founding_location(
        mut self,
        value: Option<MusicGroupFoundingLocation<S>>,
    ) -> Self {
        self._fields.35 = value;
        self
    }
}

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

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

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

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

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `hasGS1DigitalLink` field (optional)
    pub fn has_gs1_digital_link(
        mut self,
        value: impl Into<Option<MusicGroupHasGs1DigitalLink<S>>>,
    ) -> Self {
        self._fields.42 = value.into();
        self
    }
    /// Set the `hasGS1DigitalLink` field to an Option value (optional)
    pub fn maybe_has_gs1_digital_link(
        mut self,
        value: Option<MusicGroupHasGs1DigitalLink<S>>,
    ) -> Self {
        self._fields.42 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `hasMemberProgram` field (optional)
    pub fn has_member_program(
        mut self,
        value: impl Into<Option<MusicGroupHasMemberProgram<S>>>,
    ) -> Self {
        self._fields.43 = value.into();
        self
    }
    /// Set the `hasMemberProgram` field to an Option value (optional)
    pub fn maybe_has_member_program(
        mut self,
        value: Option<MusicGroupHasMemberProgram<S>>,
    ) -> Self {
        self._fields.43 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `hasMerchantReturnPolicy` field (optional)
    pub fn has_merchant_return_policy(
        mut self,
        value: impl Into<Option<MusicGroupHasMerchantReturnPolicy<S>>>,
    ) -> Self {
        self._fields.44 = value.into();
        self
    }
    /// Set the `hasMerchantReturnPolicy` field to an Option value (optional)
    pub fn maybe_has_merchant_return_policy(
        mut self,
        value: Option<MusicGroupHasMerchantReturnPolicy<S>>,
    ) -> Self {
        self._fields.44 = value;
        self
    }
}

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `hasProductReturnPolicy` field (optional)
    pub fn has_product_return_policy(
        mut self,
        value: impl Into<Option<MusicGroupHasProductReturnPolicy<S>>>,
    ) -> Self {
        self._fields.47 = value.into();
        self
    }
    /// Set the `hasProductReturnPolicy` field to an Option value (optional)
    pub fn maybe_has_product_return_policy(
        mut self,
        value: Option<MusicGroupHasProductReturnPolicy<S>>,
    ) -> Self {
        self._fields.47 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `hasShippingService` field (optional)
    pub fn has_shipping_service(
        mut self,
        value: impl Into<Option<MusicGroupHasShippingService<S>>>,
    ) -> Self {
        self._fields.48 = value.into();
        self
    }
    /// Set the `hasShippingService` field to an Option value (optional)
    pub fn maybe_has_shipping_service(
        mut self,
        value: Option<MusicGroupHasShippingService<S>>,
    ) -> Self {
        self._fields.48 = value;
        self
    }
}

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

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

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `iso6523Code` field (optional)
    pub fn iso6523_code(
        mut self,
        value: impl Into<Option<MusicGroupIso6523Code<S>>>,
    ) -> Self {
        self._fields.53 = value.into();
        self
    }
    /// Set the `iso6523Code` field to an Option value (optional)
    pub fn maybe_iso6523_code(
        mut self,
        value: Option<MusicGroupIso6523Code<S>>,
    ) -> Self {
        self._fields.53 = value;
        self
    }
}

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

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `legalAddress` field (optional)
    pub fn legal_address(
        mut self,
        value: impl Into<Option<MusicGroupLegalAddress<S>>>,
    ) -> Self {
        self._fields.57 = value.into();
        self
    }
    /// Set the `legalAddress` field to an Option value (optional)
    pub fn maybe_legal_address(
        mut self,
        value: Option<MusicGroupLegalAddress<S>>,
    ) -> Self {
        self._fields.57 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `legalName` field (optional)
    pub fn legal_name(
        mut self,
        value: impl Into<Option<MusicGroupLegalName<S>>>,
    ) -> Self {
        self._fields.58 = value.into();
        self
    }
    /// Set the `legalName` field to an Option value (optional)
    pub fn maybe_legal_name(mut self, value: Option<MusicGroupLegalName<S>>) -> Self {
        self._fields.58 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `legalRepresentative` field (optional)
    pub fn legal_representative(
        mut self,
        value: impl Into<Option<MusicGroupLegalRepresentative<S>>>,
    ) -> Self {
        self._fields.59 = value.into();
        self
    }
    /// Set the `legalRepresentative` field to an Option value (optional)
    pub fn maybe_legal_representative(
        mut self,
        value: Option<MusicGroupLegalRepresentative<S>>,
    ) -> Self {
        self._fields.59 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `leiCode` field (optional)
    pub fn lei_code(mut self, value: impl Into<Option<MusicGroupLeiCode<S>>>) -> Self {
        self._fields.60 = value.into();
        self
    }
    /// Set the `leiCode` field to an Option value (optional)
    pub fn maybe_lei_code(mut self, value: Option<MusicGroupLeiCode<S>>) -> Self {
        self._fields.60 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `location` field (optional)
    pub fn location(mut self, value: impl Into<Option<MusicGroupLocation<S>>>) -> Self {
        self._fields.61 = value.into();
        self
    }
    /// Set the `location` field to an Option value (optional)
    pub fn maybe_location(mut self, value: Option<MusicGroupLocation<S>>) -> Self {
        self._fields.61 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `logo` field (optional)
    pub fn logo(mut self, value: impl Into<Option<MusicGroupLogo<S>>>) -> Self {
        self._fields.62 = value.into();
        self
    }
    /// Set the `logo` field to an Option value (optional)
    pub fn maybe_logo(mut self, value: Option<MusicGroupLogo<S>>) -> Self {
        self._fields.62 = value;
        self
    }
}

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `member` field (optional)
    pub fn member(mut self, value: impl Into<Option<MusicGroupMember<S>>>) -> Self {
        self._fields.65 = value.into();
        self
    }
    /// Set the `member` field to an Option value (optional)
    pub fn maybe_member(mut self, value: Option<MusicGroupMember<S>>) -> Self {
        self._fields.65 = value;
        self
    }
}

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `members` field (optional)
    pub fn members(mut self, value: impl Into<Option<MusicGroupMembers<S>>>) -> Self {
        self._fields.67 = value.into();
        self
    }
    /// Set the `members` field to an Option value (optional)
    pub fn maybe_members(mut self, value: Option<MusicGroupMembers<S>>) -> Self {
        self._fields.67 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `musicGroupMember` field (optional)
    pub fn music_group_member(
        mut self,
        value: impl Into<Option<MusicGroupMusicGroupMember<S>>>,
    ) -> Self {
        self._fields.68 = value.into();
        self
    }
    /// Set the `musicGroupMember` field to an Option value (optional)
    pub fn maybe_music_group_member(
        mut self,
        value: Option<MusicGroupMusicGroupMember<S>>,
    ) -> Self {
        self._fields.68 = value;
        self
    }
}

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `nonprofitStatus` field (optional)
    pub fn nonprofit_status(
        mut self,
        value: impl Into<Option<MusicGroupNonprofitStatus<S>>>,
    ) -> Self {
        self._fields.71 = value.into();
        self
    }
    /// Set the `nonprofitStatus` field to an Option value (optional)
    pub fn maybe_nonprofit_status(
        mut self,
        value: Option<MusicGroupNonprofitStatus<S>>,
    ) -> Self {
        self._fields.71 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `numberOfEmployees` field (optional)
    pub fn number_of_employees(
        mut self,
        value: impl Into<Option<MusicGroupNumberOfEmployees<S>>>,
    ) -> Self {
        self._fields.72 = value.into();
        self
    }
    /// Set the `numberOfEmployees` field to an Option value (optional)
    pub fn maybe_number_of_employees(
        mut self,
        value: Option<MusicGroupNumberOfEmployees<S>>,
    ) -> Self {
        self._fields.72 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `ownershipFundingInfo` field (optional)
    pub fn ownership_funding_info(
        mut self,
        value: impl Into<Option<MusicGroupOwnershipFundingInfo<S>>>,
    ) -> Self {
        self._fields.73 = value.into();
        self
    }
    /// Set the `ownershipFundingInfo` field to an Option value (optional)
    pub fn maybe_ownership_funding_info(
        mut self,
        value: Option<MusicGroupOwnershipFundingInfo<S>>,
    ) -> Self {
        self._fields.73 = value;
        self
    }
}

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `parentOrganization` field (optional)
    pub fn parent_organization(
        mut self,
        value: impl Into<Option<MusicGroupParentOrganization<S>>>,
    ) -> Self {
        self._fields.75 = value.into();
        self
    }
    /// Set the `parentOrganization` field to an Option value (optional)
    pub fn maybe_parent_organization(
        mut self,
        value: Option<MusicGroupParentOrganization<S>>,
    ) -> Self {
        self._fields.75 = value;
        self
    }
}

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

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

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

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

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `serviceArea` field (optional)
    pub fn service_area(
        mut self,
        value: impl Into<Option<MusicGroupServiceArea<S>>>,
    ) -> Self {
        self._fields.82 = value.into();
        self
    }
    /// Set the `serviceArea` field to an Option value (optional)
    pub fn maybe_service_area(
        mut self,
        value: Option<MusicGroupServiceArea<S>>,
    ) -> Self {
        self._fields.82 = value;
        self
    }
}

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `slogan` field (optional)
    pub fn slogan(mut self, value: impl Into<Option<MusicGroupSlogan<S>>>) -> Self {
        self._fields.84 = value.into();
        self
    }
    /// Set the `slogan` field to an Option value (optional)
    pub fn maybe_slogan(mut self, value: Option<MusicGroupSlogan<S>>) -> Self {
        self._fields.84 = value;
        self
    }
}

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `subOrganization` field (optional)
    pub fn sub_organization(
        mut self,
        value: impl Into<Option<MusicGroupSubOrganization<S>>>,
    ) -> Self {
        self._fields.86 = value.into();
        self
    }
    /// Set the `subOrganization` field to an Option value (optional)
    pub fn maybe_sub_organization(
        mut self,
        value: Option<MusicGroupSubOrganization<S>>,
    ) -> Self {
        self._fields.86 = value;
        self
    }
}

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

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

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

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `track` field (optional)
    pub fn track(mut self, value: impl Into<Option<MusicGroupTrack<S>>>) -> Self {
        self._fields.90 = value.into();
        self
    }
    /// Set the `track` field to an Option value (optional)
    pub fn maybe_track(mut self, value: Option<MusicGroupTrack<S>>) -> Self {
        self._fields.90 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `tracks` field (optional)
    pub fn tracks(mut self, value: impl Into<Option<MusicGroupTracks<S>>>) -> Self {
        self._fields.91 = value.into();
        self
    }
    /// Set the `tracks` field to an Option value (optional)
    pub fn maybe_tracks(mut self, value: Option<MusicGroupTracks<S>>) -> Self {
        self._fields.91 = value;
        self
    }
}

impl<St: music_group_state::State, S: BosStr> MusicGroupBuilder<St, S> {
    /// Set the `unnamedSourcesPolicy` field (optional)
    pub fn unnamed_sources_policy(
        mut self,
        value: impl Into<Option<MusicGroupUnnamedSourcesPolicy<S>>>,
    ) -> Self {
        self._fields.92 = value.into();
        self
    }
    /// Set the `unnamedSourcesPolicy` field to an Option value (optional)
    pub fn maybe_unnamed_sources_policy(
        mut self,
        value: Option<MusicGroupUnnamedSourcesPolicy<S>>,
    ) -> Self {
        self._fields.92 = value;
        self
    }
}

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

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

impl<St, S: BosStr> MusicGroupBuilder<St, S>
where
    St: music_group_state::State,
{
    /// Build the final struct.
    pub fn build(self) -> MusicGroup<S> {
        MusicGroup {
            accepted_payment_method: self._fields.0,
            actionable_feedback_policy: self._fields.1,
            additional_type: self._fields.2,
            address: self._fields.3,
            agent_interaction_statistic: self._fields.4,
            aggregate_rating: self._fields.5,
            album: self._fields.6,
            albums: self._fields.7,
            alternate_name: self._fields.8,
            alumni: self._fields.9,
            area_served: self._fields.10,
            award: self._fields.11,
            awards: self._fields.12,
            brand: self._fields.13,
            company_registration: self._fields.14,
            contact_point: self._fields.15,
            contact_points: self._fields.16,
            corrections_policy: self._fields.17,
            department: self._fields.18,
            description: self._fields.19,
            disambiguating_description: self._fields.20,
            dissolution_date: self._fields.21,
            diversity_policy: self._fields.22,
            diversity_staffing_report: self._fields.23,
            duns: self._fields.24,
            email: self._fields.25,
            employee: self._fields.26,
            employees: self._fields.27,
            ethics_policy: self._fields.28,
            event: self._fields.29,
            events: self._fields.30,
            fax_number: self._fields.31,
            founder: self._fields.32,
            founders: self._fields.33,
            founding_date: self._fields.34,
            founding_location: self._fields.35,
            funder: self._fields.36,
            funding: self._fields.37,
            genre: self._fields.38,
            global_location_number: self._fields.39,
            has_certification: self._fields.40,
            has_credential: self._fields.41,
            has_gs1_digital_link: self._fields.42,
            has_member_program: self._fields.43,
            has_merchant_return_policy: self._fields.44,
            has_offer_catalog: self._fields.45,
            has_pos: self._fields.46,
            has_product_return_policy: self._fields.47,
            has_shipping_service: self._fields.48,
            identifier: self._fields.49,
            image: self._fields.50,
            interaction_statistic: self._fields.51,
            isic_v4: self._fields.52,
            iso6523_code: self._fields.53,
            keywords: self._fields.54,
            knows_about: self._fields.55,
            knows_language: self._fields.56,
            legal_address: self._fields.57,
            legal_name: self._fields.58,
            legal_representative: self._fields.59,
            lei_code: self._fields.60,
            location: self._fields.61,
            logo: self._fields.62,
            main_entity_of_page: self._fields.63,
            makes_offer: self._fields.64,
            member: self._fields.65,
            member_of: self._fields.66,
            members: self._fields.67,
            music_group_member: self._fields.68,
            naics: self._fields.69,
            name: self._fields.70,
            nonprofit_status: self._fields.71,
            number_of_employees: self._fields.72,
            ownership_funding_info: self._fields.73,
            owns: self._fields.74,
            parent_organization: self._fields.75,
            potential_action: self._fields.76,
            publishing_principles: self._fields.77,
            review: self._fields.78,
            reviews: self._fields.79,
            same_as: self._fields.80,
            seeks: self._fields.81,
            service_area: self._fields.82,
            skills: self._fields.83,
            slogan: self._fields.84,
            sponsor: self._fields.85,
            sub_organization: self._fields.86,
            subject_of: self._fields.87,
            tax_id: self._fields.88,
            telephone: self._fields.89,
            track: self._fields.90,
            tracks: self._fields.91,
            unnamed_sources_policy: self._fields.92,
            url: self._fields.93,
            vat_id: self._fields.94,
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data.
    pub fn build_with_data(
        self,
        extra_data: BTreeMap<SmolStr, Data<S>>,
    ) -> MusicGroup<S> {
        MusicGroup {
            accepted_payment_method: self._fields.0,
            actionable_feedback_policy: self._fields.1,
            additional_type: self._fields.2,
            address: self._fields.3,
            agent_interaction_statistic: self._fields.4,
            aggregate_rating: self._fields.5,
            album: self._fields.6,
            albums: self._fields.7,
            alternate_name: self._fields.8,
            alumni: self._fields.9,
            area_served: self._fields.10,
            award: self._fields.11,
            awards: self._fields.12,
            brand: self._fields.13,
            company_registration: self._fields.14,
            contact_point: self._fields.15,
            contact_points: self._fields.16,
            corrections_policy: self._fields.17,
            department: self._fields.18,
            description: self._fields.19,
            disambiguating_description: self._fields.20,
            dissolution_date: self._fields.21,
            diversity_policy: self._fields.22,
            diversity_staffing_report: self._fields.23,
            duns: self._fields.24,
            email: self._fields.25,
            employee: self._fields.26,
            employees: self._fields.27,
            ethics_policy: self._fields.28,
            event: self._fields.29,
            events: self._fields.30,
            fax_number: self._fields.31,
            founder: self._fields.32,
            founders: self._fields.33,
            founding_date: self._fields.34,
            founding_location: self._fields.35,
            funder: self._fields.36,
            funding: self._fields.37,
            genre: self._fields.38,
            global_location_number: self._fields.39,
            has_certification: self._fields.40,
            has_credential: self._fields.41,
            has_gs1_digital_link: self._fields.42,
            has_member_program: self._fields.43,
            has_merchant_return_policy: self._fields.44,
            has_offer_catalog: self._fields.45,
            has_pos: self._fields.46,
            has_product_return_policy: self._fields.47,
            has_shipping_service: self._fields.48,
            identifier: self._fields.49,
            image: self._fields.50,
            interaction_statistic: self._fields.51,
            isic_v4: self._fields.52,
            iso6523_code: self._fields.53,
            keywords: self._fields.54,
            knows_about: self._fields.55,
            knows_language: self._fields.56,
            legal_address: self._fields.57,
            legal_name: self._fields.58,
            legal_representative: self._fields.59,
            lei_code: self._fields.60,
            location: self._fields.61,
            logo: self._fields.62,
            main_entity_of_page: self._fields.63,
            makes_offer: self._fields.64,
            member: self._fields.65,
            member_of: self._fields.66,
            members: self._fields.67,
            music_group_member: self._fields.68,
            naics: self._fields.69,
            name: self._fields.70,
            nonprofit_status: self._fields.71,
            number_of_employees: self._fields.72,
            ownership_funding_info: self._fields.73,
            owns: self._fields.74,
            parent_organization: self._fields.75,
            potential_action: self._fields.76,
            publishing_principles: self._fields.77,
            review: self._fields.78,
            reviews: self._fields.79,
            same_as: self._fields.80,
            seeks: self._fields.81,
            service_area: self._fields.82,
            skills: self._fields.83,
            slogan: self._fields.84,
            sponsor: self._fields.85,
            sub_organization: self._fields.86,
            subject_of: self._fields.87,
            tax_id: self._fields.88,
            telephone: self._fields.89,
            track: self._fields.90,
            tracks: self._fields.91,
            unnamed_sources_policy: self._fields.92,
            url: self._fields.93,
            vat_id: self._fields.94,
            extra_data: Some(extra_data),
        }
    }
}