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

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

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

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

#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Serialize, Deserialize};
use crate::social_flockfeeds::lexical::r#type::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 hotel is an establishment that provides lodging paid on a short-term basis (source: Wikipedia, the free encyclopedia, see http://en.wikipedia.org/wiki/Hotel).
<br /><br />
See also the <a href="/docs/hotels.html">dedicated document on the use of schema.org for marking up hotels and other forms of accommodations</a>.*/

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct Embedded<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accepted_payment_method: Option<EmbeddedAcceptedPaymentMethod<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub actionable_feedback_policy: Option<EmbeddedActionableFeedbackPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub additional_property: Option<EmbeddedAdditionalProperty<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub additional_type: Option<EmbeddedAdditionalType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub address: Option<EmbeddedAddress<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub agent_interaction_statistic: Option<EmbeddedAgentInteractionStatistic<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub aggregate_rating: Option<EmbeddedAggregateRating<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alternate_name: Option<EmbeddedAlternateName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alumni: Option<EmbeddedAlumni<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub amenity_feature: Option<EmbeddedAmenityFeature<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub area_served: Option<EmbeddedAreaServed<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub audience: Option<EmbeddedAudience<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub available_language: Option<EmbeddedAvailableLanguage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub award: Option<EmbeddedAward<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub awards: Option<EmbeddedAwards<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub branch_code: Option<EmbeddedBranchCode<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub branch_of: Option<EmbeddedBranchOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub brand: Option<EmbeddedBrand<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub checkin_time: Option<EmbeddedCheckinTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub checkout_time: Option<EmbeddedCheckoutTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub company_registration: Option<EmbeddedCompanyRegistration<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contact_point: Option<EmbeddedContactPoint<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contact_points: Option<EmbeddedContactPoints<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contained_in: Option<EmbeddedContainedIn<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contained_in_place: Option<EmbeddedContainedInPlace<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contains_place: Option<EmbeddedContainsPlace<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub corrections_policy: Option<EmbeddedCorrectionsPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub currencies_accepted: Option<EmbeddedCurrenciesAccepted<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub department: Option<EmbeddedDepartment<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description: Option<EmbeddedDescription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub disambiguating_description: Option<EmbeddedDisambiguatingDescription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub dissolution_date: Option<EmbeddedDissolutionDate<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub diversity_policy: Option<EmbeddedDiversityPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub diversity_staffing_report: Option<EmbeddedDiversityStaffingReport<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub duns: Option<EmbeddedDuns<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub email: Option<EmbeddedEmail<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub employee: Option<EmbeddedEmployee<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub employees: Option<EmbeddedEmployees<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub ethics_policy: Option<EmbeddedEthicsPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub event: Option<EmbeddedEvent<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub events: Option<EmbeddedEvents<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub fax_number: Option<EmbeddedFaxNumber<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub founder: Option<EmbeddedFounder<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub founders: Option<EmbeddedFounders<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub founding_date: Option<EmbeddedFoundingDate<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub founding_location: Option<EmbeddedFoundingLocation<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub funder: Option<EmbeddedFunder<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub funding: Option<EmbeddedFunding<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo: Option<EmbeddedGeo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_contains: Option<EmbeddedGeoContains<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_covered_by: Option<EmbeddedGeoCoveredBy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_covers: Option<EmbeddedGeoCovers<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_crosses: Option<EmbeddedGeoCrosses<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_disjoint: Option<EmbeddedGeoDisjoint<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_equals: Option<EmbeddedGeoEquals<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_intersects: Option<EmbeddedGeoIntersects<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_overlaps: Option<EmbeddedGeoOverlaps<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_touches: Option<EmbeddedGeoTouches<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_within: Option<EmbeddedGeoWithin<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub global_location_number: Option<EmbeddedGlobalLocationNumber<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_certification: Option<EmbeddedHasCertification<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_credential: Option<EmbeddedHasCredential<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_drive_through_service: Option<EmbeddedHasDriveThroughService<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_gs1_digital_link: Option<EmbeddedHasGs1DigitalLink<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_map: Option<EmbeddedHasMap<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_member_program: Option<EmbeddedHasMemberProgram<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_merchant_return_policy: Option<EmbeddedHasMerchantReturnPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_offer_catalog: Option<EmbeddedHasOfferCatalog<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_pos: Option<EmbeddedHasPos<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_product_return_policy: Option<EmbeddedHasProductReturnPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_shipping_service: Option<EmbeddedHasShippingService<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub identifier: Option<EmbeddedIdentifier<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub image: Option<EmbeddedImage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub interaction_statistic: Option<EmbeddedInteractionStatistic<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_accessible_for_free: Option<EmbeddedIsAccessibleForFree<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub isic_v4: Option<EmbeddedIsicV4<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub iso6523_code: Option<EmbeddedIso6523Code<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub keywords: Option<EmbeddedKeywords<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub knows_about: Option<EmbeddedKnowsAbout<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub knows_language: Option<EmbeddedKnowsLanguage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub latitude: Option<EmbeddedLatitude<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub legal_address: Option<EmbeddedLegalAddress<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub legal_name: Option<EmbeddedLegalName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub legal_representative: Option<EmbeddedLegalRepresentative<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub lei_code: Option<EmbeddedLeiCode<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub location: Option<EmbeddedLocation<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub logo: Option<EmbeddedLogo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub longitude: Option<EmbeddedLongitude<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub main_entity_of_page: Option<EmbeddedMainEntityOfPage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub makes_offer: Option<EmbeddedMakesOffer<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub map: Option<EmbeddedMap<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub maps: Option<EmbeddedMaps<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub maximum_attendee_capacity: Option<EmbeddedMaximumAttendeeCapacity<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub member: Option<EmbeddedMember<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub member_of: Option<EmbeddedMemberOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub members: Option<EmbeddedMembers<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub naics: Option<EmbeddedNaics<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub name: Option<EmbeddedName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub nonprofit_status: Option<EmbeddedNonprofitStatus<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub number_of_employees: Option<EmbeddedNumberOfEmployees<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub number_of_rooms: Option<EmbeddedNumberOfRooms<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub opening_hours: Option<EmbeddedOpeningHours<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub opening_hours_specification: Option<EmbeddedOpeningHoursSpecification<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub ownership_funding_info: Option<EmbeddedOwnershipFundingInfo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub owns: Option<EmbeddedOwns<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub parent_organization: Option<EmbeddedParentOrganization<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub payment_accepted: Option<EmbeddedPaymentAccepted<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub pets_allowed: Option<EmbeddedPetsAllowed<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub photo: Option<EmbeddedPhoto<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub photos: Option<EmbeddedPhotos<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub potential_action: Option<EmbeddedPotentialAction<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub price_range: Option<EmbeddedPriceRange<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub public_access: Option<EmbeddedPublicAccess<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publishing_principles: Option<EmbeddedPublishingPrinciples<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub review: Option<EmbeddedReview<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub reviews: Option<EmbeddedReviews<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub same_as: Option<EmbeddedSameAs<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub seeks: Option<EmbeddedSeeks<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub service_area: Option<EmbeddedServiceArea<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub skills: Option<EmbeddedSkills<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub slogan: Option<EmbeddedSlogan<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub smoking_allowed: Option<EmbeddedSmokingAllowed<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub special_opening_hours_specification: Option<
        EmbeddedSpecialOpeningHoursSpecification<'a>,
    >,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sponsor: Option<EmbeddedSponsor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub star_rating: Option<EmbeddedStarRating<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sub_organization: Option<EmbeddedSubOrganization<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub subject_of: Option<EmbeddedSubjectOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub tax_id: Option<EmbeddedTaxId<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub telephone: Option<EmbeddedTelephone<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub tour_booking_page: Option<EmbeddedTourBookingPage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub unnamed_sources_policy: Option<EmbeddedUnnamedSourcesPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub url: Option<EmbeddedUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub vat_id: Option<EmbeddedVatId<'a>>,
}


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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


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


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

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


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


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

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


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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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


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

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

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

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


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


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


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

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

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

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

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

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

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

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

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


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


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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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


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

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

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

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

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

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

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct Hotel<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub accepted_payment_method: Option<HotelAcceptedPaymentMethod<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub actionable_feedback_policy: Option<HotelActionableFeedbackPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub additional_property: Option<HotelAdditionalProperty<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub additional_type: Option<HotelAdditionalType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub address: Option<HotelAddress<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub agent_interaction_statistic: Option<HotelAgentInteractionStatistic<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub aggregate_rating: Option<HotelAggregateRating<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alternate_name: Option<HotelAlternateName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alumni: Option<HotelAlumni<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub amenity_feature: Option<HotelAmenityFeature<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub area_served: Option<HotelAreaServed<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub audience: Option<HotelAudience<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub available_language: Option<HotelAvailableLanguage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub award: Option<HotelAward<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub awards: Option<HotelAwards<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub branch_code: Option<HotelBranchCode<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub branch_of: Option<HotelBranchOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub brand: Option<HotelBrand<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub checkin_time: Option<HotelCheckinTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub checkout_time: Option<HotelCheckoutTime<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub company_registration: Option<HotelCompanyRegistration<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contact_point: Option<HotelContactPoint<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contact_points: Option<HotelContactPoints<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contained_in: Option<HotelContainedIn<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contained_in_place: Option<HotelContainedInPlace<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub contains_place: Option<HotelContainsPlace<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub corrections_policy: Option<HotelCorrectionsPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub currencies_accepted: Option<HotelCurrenciesAccepted<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub department: Option<HotelDepartment<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description: Option<HotelDescription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub disambiguating_description: Option<HotelDisambiguatingDescription<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub dissolution_date: Option<HotelDissolutionDate<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub diversity_policy: Option<HotelDiversityPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub diversity_staffing_report: Option<HotelDiversityStaffingReport<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub duns: Option<HotelDuns<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub email: Option<HotelEmail<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub employee: Option<HotelEmployee<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub employees: Option<HotelEmployees<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub ethics_policy: Option<HotelEthicsPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub event: Option<HotelEvent<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub events: Option<HotelEvents<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub fax_number: Option<HotelFaxNumber<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub founder: Option<HotelFounder<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub founders: Option<HotelFounders<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub founding_date: Option<HotelFoundingDate<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub founding_location: Option<HotelFoundingLocation<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub funder: Option<HotelFunder<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub funding: Option<HotelFunding<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo: Option<HotelGeo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_contains: Option<HotelGeoContains<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_covered_by: Option<HotelGeoCoveredBy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_covers: Option<HotelGeoCovers<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_crosses: Option<HotelGeoCrosses<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_disjoint: Option<HotelGeoDisjoint<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_equals: Option<HotelGeoEquals<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_intersects: Option<HotelGeoIntersects<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_overlaps: Option<HotelGeoOverlaps<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_touches: Option<HotelGeoTouches<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub geo_within: Option<HotelGeoWithin<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub global_location_number: Option<HotelGlobalLocationNumber<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_certification: Option<HotelHasCertification<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_credential: Option<HotelHasCredential<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_drive_through_service: Option<HotelHasDriveThroughService<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_gs1_digital_link: Option<HotelHasGs1DigitalLink<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_map: Option<HotelHasMap<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_member_program: Option<HotelHasMemberProgram<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_merchant_return_policy: Option<HotelHasMerchantReturnPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_offer_catalog: Option<HotelHasOfferCatalog<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_pos: Option<HotelHasPos<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_product_return_policy: Option<HotelHasProductReturnPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub has_shipping_service: Option<HotelHasShippingService<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub identifier: Option<HotelIdentifier<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub image: Option<HotelImage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub interaction_statistic: Option<HotelInteractionStatistic<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub is_accessible_for_free: Option<HotelIsAccessibleForFree<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub isic_v4: Option<HotelIsicV4<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub iso6523_code: Option<HotelIso6523Code<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub keywords: Option<HotelKeywords<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub knows_about: Option<HotelKnowsAbout<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub knows_language: Option<HotelKnowsLanguage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub latitude: Option<HotelLatitude<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub legal_address: Option<HotelLegalAddress<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub legal_name: Option<HotelLegalName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub legal_representative: Option<HotelLegalRepresentative<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub lei_code: Option<HotelLeiCode<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub location: Option<HotelLocation<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub logo: Option<HotelLogo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub longitude: Option<HotelLongitude<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub main_entity_of_page: Option<HotelMainEntityOfPage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub makes_offer: Option<HotelMakesOffer<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub map: Option<HotelMap<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub maps: Option<HotelMaps<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub maximum_attendee_capacity: Option<HotelMaximumAttendeeCapacity<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub member: Option<HotelMember<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub member_of: Option<HotelMemberOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub members: Option<HotelMembers<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub naics: Option<HotelNaics<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub name: Option<HotelName<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub nonprofit_status: Option<HotelNonprofitStatus<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub number_of_employees: Option<HotelNumberOfEmployees<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub number_of_rooms: Option<HotelNumberOfRooms<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub opening_hours: Option<HotelOpeningHours<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub opening_hours_specification: Option<HotelOpeningHoursSpecification<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub ownership_funding_info: Option<HotelOwnershipFundingInfo<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub owns: Option<HotelOwns<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub parent_organization: Option<HotelParentOrganization<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub payment_accepted: Option<HotelPaymentAccepted<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub pets_allowed: Option<HotelPetsAllowed<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub photo: Option<HotelPhoto<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub photos: Option<HotelPhotos<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub potential_action: Option<HotelPotentialAction<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub price_range: Option<HotelPriceRange<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub public_access: Option<HotelPublicAccess<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub publishing_principles: Option<HotelPublishingPrinciples<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub review: Option<HotelReview<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub reviews: Option<HotelReviews<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub same_as: Option<HotelSameAs<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub seeks: Option<HotelSeeks<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub service_area: Option<HotelServiceArea<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub skills: Option<HotelSkills<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub slogan: Option<HotelSlogan<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub smoking_allowed: Option<HotelSmokingAllowed<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub special_opening_hours_specification: Option<
        HotelSpecialOpeningHoursSpecification<'a>,
    >,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sponsor: Option<HotelSponsor<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub star_rating: Option<HotelStarRating<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sub_organization: Option<HotelSubOrganization<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub subject_of: Option<HotelSubjectOf<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub tax_id: Option<HotelTaxId<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub telephone: Option<HotelTelephone<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub tour_booking_page: Option<HotelTourBookingPage<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub unnamed_sources_policy: Option<HotelUnnamedSourcesPolicy<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub url: Option<HotelUrl<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub vat_id: Option<HotelVatId<'a>>,
}


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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


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


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

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


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


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

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


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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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


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

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

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

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


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


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


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

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

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

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

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

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

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

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

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


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


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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn lexicon_doc_social_flockfeeds_lexical_type_Hotel() -> 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.Hotel"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("embedded"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "A hotel is an establishment that provides lodging paid on a short-term basis (source: Wikipedia, the free encyclopedia, see http://en.wikipedia.org/wiki/Hotel).\n<br /><br />\nSee also the <a href=\"/docs/hotels.html\">dedicated document on the use of schema.org for marking up hotels and other forms of accommodations</a>.",
                        ),
                    ),
                    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.hotel#acceptedPaymentMethodScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#actionableFeedbackPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#actionableFeedbackPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("additionalProperty"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.PropertyValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#additionalPropertyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("additionalType"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#additionalTypeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#addressScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#aggregateRatingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternateName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#alternateNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#alumniList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("amenityFeature"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.LocationFeatureSpecification#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#amenityFeatureList")
                                ],
                                ..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.hotel#areaServedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#areaServedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("audience"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Audience#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#audienceList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("availableLanguage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Language#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#availableLanguageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#availableLanguageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("award"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#awardScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#awardList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("awards"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#awardsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#awardsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("branchCode"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#branchCodeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#branchCodeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("branchOf"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#branchOfList")
                                ],
                                ..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.hotel#brandList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("checkinTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#checkinTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#checkinTimeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("checkoutTime"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#checkoutTimeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#checkoutTimeList")
                                ],
                                ..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.hotel#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.hotel#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.hotel#contactPointsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("containedIn"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#containedInList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("containedInPlace"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#containedInPlaceList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("containsPlace"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#containsPlaceList")
                                ],
                                ..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.hotel#correctionsPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#correctionsPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("currenciesAccepted"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#currenciesAcceptedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#currenciesAcceptedList")
                                ],
                                ..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.hotel#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.hotel#descriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#descriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("disambiguatingDescription"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#disambiguatingDescriptionScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#disambiguatingDescriptionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("dissolutionDate"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#dissolutionDateScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#diversityPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#diversityStaffingReportScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#diversityStaffingReportList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("duns"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#dunsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#dunsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("email"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#emailScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#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.hotel#ethicsPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#eventsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("faxNumber"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#faxNumberScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#foundersList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("foundingDate"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#foundingDateScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#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.hotel#fundingList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geo"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeoCoordinates#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeoShape#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoContains"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoContainsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoCoveredBy"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoCoveredByList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoCovers"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoCoversList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoCrosses"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoCrossesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoDisjoint"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoDisjointList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoEquals"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoEqualsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoIntersects"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoIntersectsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoOverlaps"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoOverlapsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoTouches"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoTouchesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("geoWithin"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoWithinList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("globalLocationNumber"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#globalLocationNumberScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#hasCredentialList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasDriveThroughService"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasDriveThroughServiceScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasDriveThroughServiceList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasGS1DigitalLink"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasGS1DigitalLinkScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasGS1DigitalLinkList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasMap"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Map#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasMapScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasMapList")
                                ],
                                ..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.hotel#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.hotel#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.hotel#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.hotel#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.hotel#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.hotel#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.hotel#identifierScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#imageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#interactionStatisticList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isAccessibleForFree"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#isAccessibleForFreeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#isAccessibleForFreeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("isicV4"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#isicV4Scalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#isicV4List")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("iso6523Code"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#iso6523CodeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#keywordsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#knowsAboutScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#knowsLanguageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#knowsLanguageList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("latitude"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#latitudeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#latitudeList")
                                ],
                                ..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.hotel#legalAddressList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("legalName"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#legalNameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#legalRepresentativeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("leiCode"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#leiCodeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#locationScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#logoScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#logoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("longitude"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#longitudeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#longitudeList")
                                ],
                                ..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.hotel#mainEntityOfPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#makesOfferList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("map"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#mapScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#mapList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("maps"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#mapsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#mapsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("maximumAttendeeCapacity"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#maximumAttendeeCapacityScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#maximumAttendeeCapacityList")
                                ],
                                ..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.hotel#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.hotel#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.hotel#membersList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("naics"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#naicsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#naicsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#nameScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#nonprofitStatusScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#numberOfEmployeesList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("numberOfRooms"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#numberOfRoomsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#numberOfRoomsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("openingHours"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#openingHoursScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#openingHoursList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("openingHoursSpecification"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.OpeningHoursSpecification#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#openingHoursSpecificationList")
                                ],
                                ..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.hotel#ownershipFundingInfoScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#parentOrganizationList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("paymentAccepted"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#paymentAcceptedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#paymentAcceptedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("petsAllowed"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#petsAllowedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#petsAllowedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("photo"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Photograph#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#photoList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("photos"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.type.Photograph#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#photosList")
                                ],
                                ..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.hotel#potentialActionList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("priceRange"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#priceRangeScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#priceRangeList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("publicAccess"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#publicAccessScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#publicAccessList")
                                ],
                                ..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.hotel#publishingPrinciplesScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#reviewsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sameAs"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#sameAsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#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.hotel#skillsScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#skillsList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("slogan"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#sloganScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#sloganList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("smokingAllowed"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#smokingAllowedScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#smokingAllowedList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("specialOpeningHoursSpecification"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.OpeningHoursSpecification#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#specialOpeningHoursSpecificationList")
                                ],
                                ..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.hotel#sponsorList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("starRating"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.type.Rating#embedded"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#starRatingList")
                                ],
                                ..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.hotel#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.hotel#subjectOfList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("taxID"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#taxIDScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#taxIDList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("telephone"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#telephoneScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#telephoneList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("tourBookingPage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#tourBookingPageScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#tourBookingPageList")
                                ],
                                ..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.hotel#unnamedSourcesPolicyScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#unnamedSourcesPolicyList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("url"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#urlScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#urlList")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("vatID"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#vatIDScalar"),
                                    CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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 hotel is an establishment that provides lodging paid on a short-term basis (source: Wikipedia, the free encyclopedia, see http://en.wikipedia.org/wiki/Hotel).\n<br /><br />\nSee also the <a href=\"/docs/hotels.html\">dedicated document on the use of schema.org for marking up hotels and other forms of accommodations</a>.",
                            ),
                        ),
                        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.hotel#acceptedPaymentMethodScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#actionableFeedbackPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#actionableFeedbackPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("additionalProperty"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.PropertyValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#additionalPropertyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("additionalType"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#additionalTypeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#addressScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#aggregateRatingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("alternateName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#alternateNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#alumniList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("amenityFeature"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.LocationFeatureSpecification#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#amenityFeatureList")
                                    ],
                                    ..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.hotel#areaServedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#areaServedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("audience"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Audience#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#audienceList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("availableLanguage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Language#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#availableLanguageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#availableLanguageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("award"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#awardScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#awardList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("awards"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#awardsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#awardsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("branchCode"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#branchCodeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#branchCodeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("branchOf"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Organization#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#branchOfList")
                                    ],
                                    ..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.hotel#brandList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("checkinTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#checkinTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#checkinTimeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("checkoutTime"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#checkoutTimeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#checkoutTimeList")
                                    ],
                                    ..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.hotel#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.hotel#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.hotel#contactPointsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("containedIn"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#containedInList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("containedInPlace"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#containedInPlaceList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("containsPlace"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#containsPlaceList")
                                    ],
                                    ..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.hotel#correctionsPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#correctionsPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("currenciesAccepted"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#currenciesAcceptedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#currenciesAcceptedList")
                                    ],
                                    ..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.hotel#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.hotel#descriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#descriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("disambiguatingDescription"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#disambiguatingDescriptionScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#disambiguatingDescriptionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("dissolutionDate"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#dissolutionDateScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#diversityPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#diversityStaffingReportScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#diversityStaffingReportList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("duns"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#dunsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#dunsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("email"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#emailScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#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.hotel#ethicsPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#eventsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("faxNumber"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#faxNumberScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#foundersList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("foundingDate"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#foundingDateScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#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.hotel#fundingList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geo"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeoCoordinates#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeoShape#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoContains"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoContainsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoCoveredBy"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoCoveredByList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoCovers"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoCoversList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoCrosses"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoCrossesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoDisjoint"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoDisjointList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoEquals"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoEqualsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoIntersects"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoIntersectsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoOverlaps"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoOverlapsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoTouches"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoTouchesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("geoWithin"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.GeospatialGeometry#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Place#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#geoWithinList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("globalLocationNumber"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#globalLocationNumberScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#hasCredentialList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasDriveThroughService"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasDriveThroughServiceScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasDriveThroughServiceList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasGS1DigitalLink"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasGS1DigitalLinkScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasGS1DigitalLinkList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("hasMap"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Map#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasMapScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#hasMapList")
                                    ],
                                    ..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.hotel#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.hotel#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.hotel#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.hotel#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.hotel#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.hotel#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.hotel#identifierScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#imageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#interactionStatisticList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isAccessibleForFree"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#isAccessibleForFreeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#isAccessibleForFreeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("isicV4"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#isicV4Scalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#isicV4List")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("iso6523Code"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#iso6523CodeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#keywordsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#knowsAboutScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#knowsLanguageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#knowsLanguageList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("latitude"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#latitudeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#latitudeList")
                                    ],
                                    ..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.hotel#legalAddressList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("legalName"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#legalNameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#legalRepresentativeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("leiCode"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#leiCodeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#locationScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#logoScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#logoList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("longitude"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#longitudeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#longitudeList")
                                    ],
                                    ..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.hotel#mainEntityOfPageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#makesOfferList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("map"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#mapScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#mapList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("maps"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#mapsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#mapsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("maximumAttendeeCapacity"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#maximumAttendeeCapacityScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#maximumAttendeeCapacityList")
                                    ],
                                    ..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.hotel#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.hotel#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.hotel#membersList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("naics"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#naicsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#naicsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("name"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#nameScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#nonprofitStatusScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#numberOfEmployeesList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("numberOfRooms"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.QuantitativeValue#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#numberOfRoomsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#numberOfRoomsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("openingHours"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#openingHoursScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#openingHoursList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("openingHoursSpecification"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.OpeningHoursSpecification#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#openingHoursSpecificationList")
                                    ],
                                    ..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.hotel#ownershipFundingInfoScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#parentOrganizationList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("paymentAccepted"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#paymentAcceptedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#paymentAcceptedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("petsAllowed"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#petsAllowedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#petsAllowedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("photo"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Photograph#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#photoList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("photos"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.ImageObject#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.type.Photograph#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#photosList")
                                    ],
                                    ..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.hotel#potentialActionList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("priceRange"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#priceRangeScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#priceRangeList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("publicAccess"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#publicAccessScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#publicAccessList")
                                    ],
                                    ..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.hotel#publishingPrinciplesScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#reviewsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("sameAs"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#sameAsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#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.hotel#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.hotel#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.hotel#skillsScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#skillsList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("slogan"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#sloganScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#sloganList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("smokingAllowed"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#smokingAllowedScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#smokingAllowedList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("specialOpeningHoursSpecification"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.OpeningHoursSpecification#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#specialOpeningHoursSpecificationList")
                                    ],
                                    ..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.hotel#sponsorList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("starRating"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.type.Rating#embedded"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#starRatingList")
                                    ],
                                    ..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.hotel#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.hotel#subjectOfList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("taxID"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#taxIDScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#taxIDList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("telephone"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#telephoneScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#telephoneList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("tourBookingPage"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#tourBookingPageScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#tourBookingPageList")
                                    ],
                                    ..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.hotel#unnamedSourcesPolicyScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#unnamedSourcesPolicyList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("url"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#urlScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#urlList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("vatID"),
                                LexObjectProperty::Union(LexRefUnion {
                                    refs: vec![
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#vatIDScalar"),
                                        CowStr::new_static("social.flockfeeds.lexical.prop.hotel#vatIDList")
                                    ],
                                    ..Default::default()
                                }),
                            );
                            map
                        },
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}

pub mod hotel_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 HotelBuilder<'a, S: hotel_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<HotelAcceptedPaymentMethod<'a>>,
        Option<HotelActionableFeedbackPolicy<'a>>,
        Option<HotelAdditionalProperty<'a>>,
        Option<HotelAdditionalType<'a>>,
        Option<HotelAddress<'a>>,
        Option<HotelAgentInteractionStatistic<'a>>,
        Option<HotelAggregateRating<'a>>,
        Option<HotelAlternateName<'a>>,
        Option<HotelAlumni<'a>>,
        Option<HotelAmenityFeature<'a>>,
        Option<HotelAreaServed<'a>>,
        Option<HotelAudience<'a>>,
        Option<HotelAvailableLanguage<'a>>,
        Option<HotelAward<'a>>,
        Option<HotelAwards<'a>>,
        Option<HotelBranchCode<'a>>,
        Option<HotelBranchOf<'a>>,
        Option<HotelBrand<'a>>,
        Option<HotelCheckinTime<'a>>,
        Option<HotelCheckoutTime<'a>>,
        Option<HotelCompanyRegistration<'a>>,
        Option<HotelContactPoint<'a>>,
        Option<HotelContactPoints<'a>>,
        Option<HotelContainedIn<'a>>,
        Option<HotelContainedInPlace<'a>>,
        Option<HotelContainsPlace<'a>>,
        Option<HotelCorrectionsPolicy<'a>>,
        Option<HotelCurrenciesAccepted<'a>>,
        Option<HotelDepartment<'a>>,
        Option<HotelDescription<'a>>,
        Option<HotelDisambiguatingDescription<'a>>,
        Option<HotelDissolutionDate<'a>>,
        Option<HotelDiversityPolicy<'a>>,
        Option<HotelDiversityStaffingReport<'a>>,
        Option<HotelDuns<'a>>,
        Option<HotelEmail<'a>>,
        Option<HotelEmployee<'a>>,
        Option<HotelEmployees<'a>>,
        Option<HotelEthicsPolicy<'a>>,
        Option<HotelEvent<'a>>,
        Option<HotelEvents<'a>>,
        Option<HotelFaxNumber<'a>>,
        Option<HotelFounder<'a>>,
        Option<HotelFounders<'a>>,
        Option<HotelFoundingDate<'a>>,
        Option<HotelFoundingLocation<'a>>,
        Option<HotelFunder<'a>>,
        Option<HotelFunding<'a>>,
        Option<HotelGeo<'a>>,
        Option<HotelGeoContains<'a>>,
        Option<HotelGeoCoveredBy<'a>>,
        Option<HotelGeoCovers<'a>>,
        Option<HotelGeoCrosses<'a>>,
        Option<HotelGeoDisjoint<'a>>,
        Option<HotelGeoEquals<'a>>,
        Option<HotelGeoIntersects<'a>>,
        Option<HotelGeoOverlaps<'a>>,
        Option<HotelGeoTouches<'a>>,
        Option<HotelGeoWithin<'a>>,
        Option<HotelGlobalLocationNumber<'a>>,
        Option<HotelHasCertification<'a>>,
        Option<HotelHasCredential<'a>>,
        Option<HotelHasDriveThroughService<'a>>,
        Option<HotelHasGs1DigitalLink<'a>>,
        Option<HotelHasMap<'a>>,
        Option<HotelHasMemberProgram<'a>>,
        Option<HotelHasMerchantReturnPolicy<'a>>,
        Option<HotelHasOfferCatalog<'a>>,
        Option<HotelHasPos<'a>>,
        Option<HotelHasProductReturnPolicy<'a>>,
        Option<HotelHasShippingService<'a>>,
        Option<HotelIdentifier<'a>>,
        Option<HotelImage<'a>>,
        Option<HotelInteractionStatistic<'a>>,
        Option<HotelIsAccessibleForFree<'a>>,
        Option<HotelIsicV4<'a>>,
        Option<HotelIso6523Code<'a>>,
        Option<HotelKeywords<'a>>,
        Option<HotelKnowsAbout<'a>>,
        Option<HotelKnowsLanguage<'a>>,
        Option<HotelLatitude<'a>>,
        Option<HotelLegalAddress<'a>>,
        Option<HotelLegalName<'a>>,
        Option<HotelLegalRepresentative<'a>>,
        Option<HotelLeiCode<'a>>,
        Option<HotelLocation<'a>>,
        Option<HotelLogo<'a>>,
        Option<HotelLongitude<'a>>,
        Option<HotelMainEntityOfPage<'a>>,
        Option<HotelMakesOffer<'a>>,
        Option<HotelMap<'a>>,
        Option<HotelMaps<'a>>,
        Option<HotelMaximumAttendeeCapacity<'a>>,
        Option<HotelMember<'a>>,
        Option<HotelMemberOf<'a>>,
        Option<HotelMembers<'a>>,
        Option<HotelNaics<'a>>,
        Option<HotelName<'a>>,
        Option<HotelNonprofitStatus<'a>>,
        Option<HotelNumberOfEmployees<'a>>,
        Option<HotelNumberOfRooms<'a>>,
        Option<HotelOpeningHours<'a>>,
        Option<HotelOpeningHoursSpecification<'a>>,
        Option<HotelOwnershipFundingInfo<'a>>,
        Option<HotelOwns<'a>>,
        Option<HotelParentOrganization<'a>>,
        Option<HotelPaymentAccepted<'a>>,
        Option<HotelPetsAllowed<'a>>,
        Option<HotelPhoto<'a>>,
        Option<HotelPhotos<'a>>,
        Option<HotelPotentialAction<'a>>,
        Option<HotelPriceRange<'a>>,
        Option<HotelPublicAccess<'a>>,
        Option<HotelPublishingPrinciples<'a>>,
        Option<HotelReview<'a>>,
        Option<HotelReviews<'a>>,
        Option<HotelSameAs<'a>>,
        Option<HotelSeeks<'a>>,
        Option<HotelServiceArea<'a>>,
        Option<HotelSkills<'a>>,
        Option<HotelSlogan<'a>>,
        Option<HotelSmokingAllowed<'a>>,
        Option<HotelSpecialOpeningHoursSpecification<'a>>,
        Option<HotelSponsor<'a>>,
        Option<HotelStarRating<'a>>,
        Option<HotelSubOrganization<'a>>,
        Option<HotelSubjectOf<'a>>,
        Option<HotelTaxId<'a>>,
        Option<HotelTelephone<'a>>,
        Option<HotelTourBookingPage<'a>>,
        Option<HotelUnnamedSourcesPolicy<'a>>,
        Option<HotelUrl<'a>>,
        Option<HotelVatId<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> Hotel<'a> {
    /// Create a new builder for this type
    pub fn new() -> HotelBuilder<'a, hotel_state::Empty> {
        HotelBuilder::new()
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `acceptedPaymentMethod` field (optional)
    pub fn accepted_payment_method(
        mut self,
        value: impl Into<Option<HotelAcceptedPaymentMethod<'a>>>,
    ) -> 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<HotelAcceptedPaymentMethod<'a>>,
    ) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `actionableFeedbackPolicy` field (optional)
    pub fn actionable_feedback_policy(
        mut self,
        value: impl Into<Option<HotelActionableFeedbackPolicy<'a>>>,
    ) -> 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<HotelActionableFeedbackPolicy<'a>>,
    ) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `additionalProperty` field (optional)
    pub fn additional_property(
        mut self,
        value: impl Into<Option<HotelAdditionalProperty<'a>>>,
    ) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `additionalProperty` field to an Option value (optional)
    pub fn maybe_additional_property(
        mut self,
        value: Option<HotelAdditionalProperty<'a>>,
    ) -> Self {
        self._fields.2 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `address` field (optional)
    pub fn address(mut self, value: impl Into<Option<HotelAddress<'a>>>) -> Self {
        self._fields.4 = value.into();
        self
    }
    /// Set the `address` field to an Option value (optional)
    pub fn maybe_address(mut self, value: Option<HotelAddress<'a>>) -> Self {
        self._fields.4 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `agentInteractionStatistic` field (optional)
    pub fn agent_interaction_statistic(
        mut self,
        value: impl Into<Option<HotelAgentInteractionStatistic<'a>>>,
    ) -> Self {
        self._fields.5 = value.into();
        self
    }
    /// Set the `agentInteractionStatistic` field to an Option value (optional)
    pub fn maybe_agent_interaction_statistic(
        mut self,
        value: Option<HotelAgentInteractionStatistic<'a>>,
    ) -> Self {
        self._fields.5 = value;
        self
    }
}

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

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `alumni` field (optional)
    pub fn alumni(mut self, value: impl Into<Option<HotelAlumni<'a>>>) -> Self {
        self._fields.8 = value.into();
        self
    }
    /// Set the `alumni` field to an Option value (optional)
    pub fn maybe_alumni(mut self, value: Option<HotelAlumni<'a>>) -> Self {
        self._fields.8 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `amenityFeature` field (optional)
    pub fn amenity_feature(
        mut self,
        value: impl Into<Option<HotelAmenityFeature<'a>>>,
    ) -> Self {
        self._fields.9 = value.into();
        self
    }
    /// Set the `amenityFeature` field to an Option value (optional)
    pub fn maybe_amenity_feature(
        mut self,
        value: Option<HotelAmenityFeature<'a>>,
    ) -> Self {
        self._fields.9 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `areaServed` field (optional)
    pub fn area_served(mut self, value: impl Into<Option<HotelAreaServed<'a>>>) -> 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<HotelAreaServed<'a>>) -> Self {
        self._fields.10 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `availableLanguage` field (optional)
    pub fn available_language(
        mut self,
        value: impl Into<Option<HotelAvailableLanguage<'a>>>,
    ) -> Self {
        self._fields.12 = value.into();
        self
    }
    /// Set the `availableLanguage` field to an Option value (optional)
    pub fn maybe_available_language(
        mut self,
        value: Option<HotelAvailableLanguage<'a>>,
    ) -> Self {
        self._fields.12 = value;
        self
    }
}

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

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `branchCode` field (optional)
    pub fn branch_code(mut self, value: impl Into<Option<HotelBranchCode<'a>>>) -> Self {
        self._fields.15 = value.into();
        self
    }
    /// Set the `branchCode` field to an Option value (optional)
    pub fn maybe_branch_code(mut self, value: Option<HotelBranchCode<'a>>) -> Self {
        self._fields.15 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `branchOf` field (optional)
    pub fn branch_of(mut self, value: impl Into<Option<HotelBranchOf<'a>>>) -> Self {
        self._fields.16 = value.into();
        self
    }
    /// Set the `branchOf` field to an Option value (optional)
    pub fn maybe_branch_of(mut self, value: Option<HotelBranchOf<'a>>) -> Self {
        self._fields.16 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `brand` field (optional)
    pub fn brand(mut self, value: impl Into<Option<HotelBrand<'a>>>) -> Self {
        self._fields.17 = value.into();
        self
    }
    /// Set the `brand` field to an Option value (optional)
    pub fn maybe_brand(mut self, value: Option<HotelBrand<'a>>) -> Self {
        self._fields.17 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `checkinTime` field (optional)
    pub fn checkin_time(
        mut self,
        value: impl Into<Option<HotelCheckinTime<'a>>>,
    ) -> Self {
        self._fields.18 = value.into();
        self
    }
    /// Set the `checkinTime` field to an Option value (optional)
    pub fn maybe_checkin_time(mut self, value: Option<HotelCheckinTime<'a>>) -> Self {
        self._fields.18 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `checkoutTime` field (optional)
    pub fn checkout_time(
        mut self,
        value: impl Into<Option<HotelCheckoutTime<'a>>>,
    ) -> Self {
        self._fields.19 = value.into();
        self
    }
    /// Set the `checkoutTime` field to an Option value (optional)
    pub fn maybe_checkout_time(mut self, value: Option<HotelCheckoutTime<'a>>) -> Self {
        self._fields.19 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `companyRegistration` field (optional)
    pub fn company_registration(
        mut self,
        value: impl Into<Option<HotelCompanyRegistration<'a>>>,
    ) -> Self {
        self._fields.20 = value.into();
        self
    }
    /// Set the `companyRegistration` field to an Option value (optional)
    pub fn maybe_company_registration(
        mut self,
        value: Option<HotelCompanyRegistration<'a>>,
    ) -> Self {
        self._fields.20 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `contactPoint` field (optional)
    pub fn contact_point(
        mut self,
        value: impl Into<Option<HotelContactPoint<'a>>>,
    ) -> Self {
        self._fields.21 = value.into();
        self
    }
    /// Set the `contactPoint` field to an Option value (optional)
    pub fn maybe_contact_point(mut self, value: Option<HotelContactPoint<'a>>) -> Self {
        self._fields.21 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `contactPoints` field (optional)
    pub fn contact_points(
        mut self,
        value: impl Into<Option<HotelContactPoints<'a>>>,
    ) -> Self {
        self._fields.22 = value.into();
        self
    }
    /// Set the `contactPoints` field to an Option value (optional)
    pub fn maybe_contact_points(
        mut self,
        value: Option<HotelContactPoints<'a>>,
    ) -> Self {
        self._fields.22 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `containedIn` field (optional)
    pub fn contained_in(
        mut self,
        value: impl Into<Option<HotelContainedIn<'a>>>,
    ) -> Self {
        self._fields.23 = value.into();
        self
    }
    /// Set the `containedIn` field to an Option value (optional)
    pub fn maybe_contained_in(mut self, value: Option<HotelContainedIn<'a>>) -> Self {
        self._fields.23 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `containedInPlace` field (optional)
    pub fn contained_in_place(
        mut self,
        value: impl Into<Option<HotelContainedInPlace<'a>>>,
    ) -> Self {
        self._fields.24 = value.into();
        self
    }
    /// Set the `containedInPlace` field to an Option value (optional)
    pub fn maybe_contained_in_place(
        mut self,
        value: Option<HotelContainedInPlace<'a>>,
    ) -> Self {
        self._fields.24 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `containsPlace` field (optional)
    pub fn contains_place(
        mut self,
        value: impl Into<Option<HotelContainsPlace<'a>>>,
    ) -> Self {
        self._fields.25 = value.into();
        self
    }
    /// Set the `containsPlace` field to an Option value (optional)
    pub fn maybe_contains_place(
        mut self,
        value: Option<HotelContainsPlace<'a>>,
    ) -> Self {
        self._fields.25 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `correctionsPolicy` field (optional)
    pub fn corrections_policy(
        mut self,
        value: impl Into<Option<HotelCorrectionsPolicy<'a>>>,
    ) -> Self {
        self._fields.26 = value.into();
        self
    }
    /// Set the `correctionsPolicy` field to an Option value (optional)
    pub fn maybe_corrections_policy(
        mut self,
        value: Option<HotelCorrectionsPolicy<'a>>,
    ) -> Self {
        self._fields.26 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `currenciesAccepted` field (optional)
    pub fn currencies_accepted(
        mut self,
        value: impl Into<Option<HotelCurrenciesAccepted<'a>>>,
    ) -> Self {
        self._fields.27 = value.into();
        self
    }
    /// Set the `currenciesAccepted` field to an Option value (optional)
    pub fn maybe_currencies_accepted(
        mut self,
        value: Option<HotelCurrenciesAccepted<'a>>,
    ) -> Self {
        self._fields.27 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `department` field (optional)
    pub fn department(mut self, value: impl Into<Option<HotelDepartment<'a>>>) -> Self {
        self._fields.28 = value.into();
        self
    }
    /// Set the `department` field to an Option value (optional)
    pub fn maybe_department(mut self, value: Option<HotelDepartment<'a>>) -> Self {
        self._fields.28 = value;
        self
    }
}

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

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `dissolutionDate` field (optional)
    pub fn dissolution_date(
        mut self,
        value: impl Into<Option<HotelDissolutionDate<'a>>>,
    ) -> Self {
        self._fields.31 = value.into();
        self
    }
    /// Set the `dissolutionDate` field to an Option value (optional)
    pub fn maybe_dissolution_date(
        mut self,
        value: Option<HotelDissolutionDate<'a>>,
    ) -> Self {
        self._fields.31 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `diversityPolicy` field (optional)
    pub fn diversity_policy(
        mut self,
        value: impl Into<Option<HotelDiversityPolicy<'a>>>,
    ) -> Self {
        self._fields.32 = value.into();
        self
    }
    /// Set the `diversityPolicy` field to an Option value (optional)
    pub fn maybe_diversity_policy(
        mut self,
        value: Option<HotelDiversityPolicy<'a>>,
    ) -> Self {
        self._fields.32 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `diversityStaffingReport` field (optional)
    pub fn diversity_staffing_report(
        mut self,
        value: impl Into<Option<HotelDiversityStaffingReport<'a>>>,
    ) -> Self {
        self._fields.33 = value.into();
        self
    }
    /// Set the `diversityStaffingReport` field to an Option value (optional)
    pub fn maybe_diversity_staffing_report(
        mut self,
        value: Option<HotelDiversityStaffingReport<'a>>,
    ) -> Self {
        self._fields.33 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `duns` field (optional)
    pub fn duns(mut self, value: impl Into<Option<HotelDuns<'a>>>) -> Self {
        self._fields.34 = value.into();
        self
    }
    /// Set the `duns` field to an Option value (optional)
    pub fn maybe_duns(mut self, value: Option<HotelDuns<'a>>) -> Self {
        self._fields.34 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `email` field (optional)
    pub fn email(mut self, value: impl Into<Option<HotelEmail<'a>>>) -> Self {
        self._fields.35 = value.into();
        self
    }
    /// Set the `email` field to an Option value (optional)
    pub fn maybe_email(mut self, value: Option<HotelEmail<'a>>) -> Self {
        self._fields.35 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `employee` field (optional)
    pub fn employee(mut self, value: impl Into<Option<HotelEmployee<'a>>>) -> Self {
        self._fields.36 = value.into();
        self
    }
    /// Set the `employee` field to an Option value (optional)
    pub fn maybe_employee(mut self, value: Option<HotelEmployee<'a>>) -> Self {
        self._fields.36 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `employees` field (optional)
    pub fn employees(mut self, value: impl Into<Option<HotelEmployees<'a>>>) -> Self {
        self._fields.37 = value.into();
        self
    }
    /// Set the `employees` field to an Option value (optional)
    pub fn maybe_employees(mut self, value: Option<HotelEmployees<'a>>) -> Self {
        self._fields.37 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `ethicsPolicy` field (optional)
    pub fn ethics_policy(
        mut self,
        value: impl Into<Option<HotelEthicsPolicy<'a>>>,
    ) -> Self {
        self._fields.38 = value.into();
        self
    }
    /// Set the `ethicsPolicy` field to an Option value (optional)
    pub fn maybe_ethics_policy(mut self, value: Option<HotelEthicsPolicy<'a>>) -> Self {
        self._fields.38 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `event` field (optional)
    pub fn event(mut self, value: impl Into<Option<HotelEvent<'a>>>) -> Self {
        self._fields.39 = value.into();
        self
    }
    /// Set the `event` field to an Option value (optional)
    pub fn maybe_event(mut self, value: Option<HotelEvent<'a>>) -> Self {
        self._fields.39 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `events` field (optional)
    pub fn events(mut self, value: impl Into<Option<HotelEvents<'a>>>) -> Self {
        self._fields.40 = value.into();
        self
    }
    /// Set the `events` field to an Option value (optional)
    pub fn maybe_events(mut self, value: Option<HotelEvents<'a>>) -> Self {
        self._fields.40 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `faxNumber` field (optional)
    pub fn fax_number(mut self, value: impl Into<Option<HotelFaxNumber<'a>>>) -> Self {
        self._fields.41 = value.into();
        self
    }
    /// Set the `faxNumber` field to an Option value (optional)
    pub fn maybe_fax_number(mut self, value: Option<HotelFaxNumber<'a>>) -> Self {
        self._fields.41 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `founder` field (optional)
    pub fn founder(mut self, value: impl Into<Option<HotelFounder<'a>>>) -> Self {
        self._fields.42 = value.into();
        self
    }
    /// Set the `founder` field to an Option value (optional)
    pub fn maybe_founder(mut self, value: Option<HotelFounder<'a>>) -> Self {
        self._fields.42 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `founders` field (optional)
    pub fn founders(mut self, value: impl Into<Option<HotelFounders<'a>>>) -> Self {
        self._fields.43 = value.into();
        self
    }
    /// Set the `founders` field to an Option value (optional)
    pub fn maybe_founders(mut self, value: Option<HotelFounders<'a>>) -> Self {
        self._fields.43 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `foundingDate` field (optional)
    pub fn founding_date(
        mut self,
        value: impl Into<Option<HotelFoundingDate<'a>>>,
    ) -> Self {
        self._fields.44 = value.into();
        self
    }
    /// Set the `foundingDate` field to an Option value (optional)
    pub fn maybe_founding_date(mut self, value: Option<HotelFoundingDate<'a>>) -> Self {
        self._fields.44 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `foundingLocation` field (optional)
    pub fn founding_location(
        mut self,
        value: impl Into<Option<HotelFoundingLocation<'a>>>,
    ) -> Self {
        self._fields.45 = value.into();
        self
    }
    /// Set the `foundingLocation` field to an Option value (optional)
    pub fn maybe_founding_location(
        mut self,
        value: Option<HotelFoundingLocation<'a>>,
    ) -> Self {
        self._fields.45 = value;
        self
    }
}

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

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geo` field (optional)
    pub fn geo(mut self, value: impl Into<Option<HotelGeo<'a>>>) -> Self {
        self._fields.48 = value.into();
        self
    }
    /// Set the `geo` field to an Option value (optional)
    pub fn maybe_geo(mut self, value: Option<HotelGeo<'a>>) -> Self {
        self._fields.48 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoContains` field (optional)
    pub fn geo_contains(
        mut self,
        value: impl Into<Option<HotelGeoContains<'a>>>,
    ) -> Self {
        self._fields.49 = value.into();
        self
    }
    /// Set the `geoContains` field to an Option value (optional)
    pub fn maybe_geo_contains(mut self, value: Option<HotelGeoContains<'a>>) -> Self {
        self._fields.49 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoCoveredBy` field (optional)
    pub fn geo_covered_by(
        mut self,
        value: impl Into<Option<HotelGeoCoveredBy<'a>>>,
    ) -> Self {
        self._fields.50 = value.into();
        self
    }
    /// Set the `geoCoveredBy` field to an Option value (optional)
    pub fn maybe_geo_covered_by(mut self, value: Option<HotelGeoCoveredBy<'a>>) -> Self {
        self._fields.50 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoCovers` field (optional)
    pub fn geo_covers(mut self, value: impl Into<Option<HotelGeoCovers<'a>>>) -> Self {
        self._fields.51 = value.into();
        self
    }
    /// Set the `geoCovers` field to an Option value (optional)
    pub fn maybe_geo_covers(mut self, value: Option<HotelGeoCovers<'a>>) -> Self {
        self._fields.51 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoCrosses` field (optional)
    pub fn geo_crosses(mut self, value: impl Into<Option<HotelGeoCrosses<'a>>>) -> Self {
        self._fields.52 = value.into();
        self
    }
    /// Set the `geoCrosses` field to an Option value (optional)
    pub fn maybe_geo_crosses(mut self, value: Option<HotelGeoCrosses<'a>>) -> Self {
        self._fields.52 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoDisjoint` field (optional)
    pub fn geo_disjoint(
        mut self,
        value: impl Into<Option<HotelGeoDisjoint<'a>>>,
    ) -> Self {
        self._fields.53 = value.into();
        self
    }
    /// Set the `geoDisjoint` field to an Option value (optional)
    pub fn maybe_geo_disjoint(mut self, value: Option<HotelGeoDisjoint<'a>>) -> Self {
        self._fields.53 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoEquals` field (optional)
    pub fn geo_equals(mut self, value: impl Into<Option<HotelGeoEquals<'a>>>) -> Self {
        self._fields.54 = value.into();
        self
    }
    /// Set the `geoEquals` field to an Option value (optional)
    pub fn maybe_geo_equals(mut self, value: Option<HotelGeoEquals<'a>>) -> Self {
        self._fields.54 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoIntersects` field (optional)
    pub fn geo_intersects(
        mut self,
        value: impl Into<Option<HotelGeoIntersects<'a>>>,
    ) -> Self {
        self._fields.55 = value.into();
        self
    }
    /// Set the `geoIntersects` field to an Option value (optional)
    pub fn maybe_geo_intersects(
        mut self,
        value: Option<HotelGeoIntersects<'a>>,
    ) -> Self {
        self._fields.55 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoOverlaps` field (optional)
    pub fn geo_overlaps(
        mut self,
        value: impl Into<Option<HotelGeoOverlaps<'a>>>,
    ) -> Self {
        self._fields.56 = value.into();
        self
    }
    /// Set the `geoOverlaps` field to an Option value (optional)
    pub fn maybe_geo_overlaps(mut self, value: Option<HotelGeoOverlaps<'a>>) -> Self {
        self._fields.56 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoTouches` field (optional)
    pub fn geo_touches(mut self, value: impl Into<Option<HotelGeoTouches<'a>>>) -> Self {
        self._fields.57 = value.into();
        self
    }
    /// Set the `geoTouches` field to an Option value (optional)
    pub fn maybe_geo_touches(mut self, value: Option<HotelGeoTouches<'a>>) -> Self {
        self._fields.57 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `geoWithin` field (optional)
    pub fn geo_within(mut self, value: impl Into<Option<HotelGeoWithin<'a>>>) -> Self {
        self._fields.58 = value.into();
        self
    }
    /// Set the `geoWithin` field to an Option value (optional)
    pub fn maybe_geo_within(mut self, value: Option<HotelGeoWithin<'a>>) -> Self {
        self._fields.58 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `globalLocationNumber` field (optional)
    pub fn global_location_number(
        mut self,
        value: impl Into<Option<HotelGlobalLocationNumber<'a>>>,
    ) -> Self {
        self._fields.59 = value.into();
        self
    }
    /// Set the `globalLocationNumber` field to an Option value (optional)
    pub fn maybe_global_location_number(
        mut self,
        value: Option<HotelGlobalLocationNumber<'a>>,
    ) -> Self {
        self._fields.59 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasCertification` field (optional)
    pub fn has_certification(
        mut self,
        value: impl Into<Option<HotelHasCertification<'a>>>,
    ) -> Self {
        self._fields.60 = value.into();
        self
    }
    /// Set the `hasCertification` field to an Option value (optional)
    pub fn maybe_has_certification(
        mut self,
        value: Option<HotelHasCertification<'a>>,
    ) -> Self {
        self._fields.60 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasCredential` field (optional)
    pub fn has_credential(
        mut self,
        value: impl Into<Option<HotelHasCredential<'a>>>,
    ) -> Self {
        self._fields.61 = value.into();
        self
    }
    /// Set the `hasCredential` field to an Option value (optional)
    pub fn maybe_has_credential(
        mut self,
        value: Option<HotelHasCredential<'a>>,
    ) -> Self {
        self._fields.61 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasDriveThroughService` field (optional)
    pub fn has_drive_through_service(
        mut self,
        value: impl Into<Option<HotelHasDriveThroughService<'a>>>,
    ) -> Self {
        self._fields.62 = value.into();
        self
    }
    /// Set the `hasDriveThroughService` field to an Option value (optional)
    pub fn maybe_has_drive_through_service(
        mut self,
        value: Option<HotelHasDriveThroughService<'a>>,
    ) -> Self {
        self._fields.62 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasGS1DigitalLink` field (optional)
    pub fn has_gs1_digital_link(
        mut self,
        value: impl Into<Option<HotelHasGs1DigitalLink<'a>>>,
    ) -> Self {
        self._fields.63 = value.into();
        self
    }
    /// Set the `hasGS1DigitalLink` field to an Option value (optional)
    pub fn maybe_has_gs1_digital_link(
        mut self,
        value: Option<HotelHasGs1DigitalLink<'a>>,
    ) -> Self {
        self._fields.63 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasMap` field (optional)
    pub fn has_map(mut self, value: impl Into<Option<HotelHasMap<'a>>>) -> Self {
        self._fields.64 = value.into();
        self
    }
    /// Set the `hasMap` field to an Option value (optional)
    pub fn maybe_has_map(mut self, value: Option<HotelHasMap<'a>>) -> Self {
        self._fields.64 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasMemberProgram` field (optional)
    pub fn has_member_program(
        mut self,
        value: impl Into<Option<HotelHasMemberProgram<'a>>>,
    ) -> Self {
        self._fields.65 = value.into();
        self
    }
    /// Set the `hasMemberProgram` field to an Option value (optional)
    pub fn maybe_has_member_program(
        mut self,
        value: Option<HotelHasMemberProgram<'a>>,
    ) -> Self {
        self._fields.65 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasMerchantReturnPolicy` field (optional)
    pub fn has_merchant_return_policy(
        mut self,
        value: impl Into<Option<HotelHasMerchantReturnPolicy<'a>>>,
    ) -> Self {
        self._fields.66 = value.into();
        self
    }
    /// Set the `hasMerchantReturnPolicy` field to an Option value (optional)
    pub fn maybe_has_merchant_return_policy(
        mut self,
        value: Option<HotelHasMerchantReturnPolicy<'a>>,
    ) -> Self {
        self._fields.66 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasOfferCatalog` field (optional)
    pub fn has_offer_catalog(
        mut self,
        value: impl Into<Option<HotelHasOfferCatalog<'a>>>,
    ) -> Self {
        self._fields.67 = value.into();
        self
    }
    /// Set the `hasOfferCatalog` field to an Option value (optional)
    pub fn maybe_has_offer_catalog(
        mut self,
        value: Option<HotelHasOfferCatalog<'a>>,
    ) -> Self {
        self._fields.67 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasPOS` field (optional)
    pub fn has_pos(mut self, value: impl Into<Option<HotelHasPos<'a>>>) -> Self {
        self._fields.68 = value.into();
        self
    }
    /// Set the `hasPOS` field to an Option value (optional)
    pub fn maybe_has_pos(mut self, value: Option<HotelHasPos<'a>>) -> Self {
        self._fields.68 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasProductReturnPolicy` field (optional)
    pub fn has_product_return_policy(
        mut self,
        value: impl Into<Option<HotelHasProductReturnPolicy<'a>>>,
    ) -> Self {
        self._fields.69 = value.into();
        self
    }
    /// Set the `hasProductReturnPolicy` field to an Option value (optional)
    pub fn maybe_has_product_return_policy(
        mut self,
        value: Option<HotelHasProductReturnPolicy<'a>>,
    ) -> Self {
        self._fields.69 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `hasShippingService` field (optional)
    pub fn has_shipping_service(
        mut self,
        value: impl Into<Option<HotelHasShippingService<'a>>>,
    ) -> Self {
        self._fields.70 = value.into();
        self
    }
    /// Set the `hasShippingService` field to an Option value (optional)
    pub fn maybe_has_shipping_service(
        mut self,
        value: Option<HotelHasShippingService<'a>>,
    ) -> Self {
        self._fields.70 = value;
        self
    }
}

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

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

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

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `isicV4` field (optional)
    pub fn isic_v4(mut self, value: impl Into<Option<HotelIsicV4<'a>>>) -> Self {
        self._fields.75 = value.into();
        self
    }
    /// Set the `isicV4` field to an Option value (optional)
    pub fn maybe_isic_v4(mut self, value: Option<HotelIsicV4<'a>>) -> Self {
        self._fields.75 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `iso6523Code` field (optional)
    pub fn iso6523_code(
        mut self,
        value: impl Into<Option<HotelIso6523Code<'a>>>,
    ) -> Self {
        self._fields.76 = value.into();
        self
    }
    /// Set the `iso6523Code` field to an Option value (optional)
    pub fn maybe_iso6523_code(mut self, value: Option<HotelIso6523Code<'a>>) -> Self {
        self._fields.76 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `knowsAbout` field (optional)
    pub fn knows_about(mut self, value: impl Into<Option<HotelKnowsAbout<'a>>>) -> Self {
        self._fields.78 = value.into();
        self
    }
    /// Set the `knowsAbout` field to an Option value (optional)
    pub fn maybe_knows_about(mut self, value: Option<HotelKnowsAbout<'a>>) -> Self {
        self._fields.78 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `knowsLanguage` field (optional)
    pub fn knows_language(
        mut self,
        value: impl Into<Option<HotelKnowsLanguage<'a>>>,
    ) -> Self {
        self._fields.79 = value.into();
        self
    }
    /// Set the `knowsLanguage` field to an Option value (optional)
    pub fn maybe_knows_language(
        mut self,
        value: Option<HotelKnowsLanguage<'a>>,
    ) -> Self {
        self._fields.79 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `latitude` field (optional)
    pub fn latitude(mut self, value: impl Into<Option<HotelLatitude<'a>>>) -> Self {
        self._fields.80 = value.into();
        self
    }
    /// Set the `latitude` field to an Option value (optional)
    pub fn maybe_latitude(mut self, value: Option<HotelLatitude<'a>>) -> Self {
        self._fields.80 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `legalAddress` field (optional)
    pub fn legal_address(
        mut self,
        value: impl Into<Option<HotelLegalAddress<'a>>>,
    ) -> Self {
        self._fields.81 = value.into();
        self
    }
    /// Set the `legalAddress` field to an Option value (optional)
    pub fn maybe_legal_address(mut self, value: Option<HotelLegalAddress<'a>>) -> Self {
        self._fields.81 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `legalName` field (optional)
    pub fn legal_name(mut self, value: impl Into<Option<HotelLegalName<'a>>>) -> Self {
        self._fields.82 = value.into();
        self
    }
    /// Set the `legalName` field to an Option value (optional)
    pub fn maybe_legal_name(mut self, value: Option<HotelLegalName<'a>>) -> Self {
        self._fields.82 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `legalRepresentative` field (optional)
    pub fn legal_representative(
        mut self,
        value: impl Into<Option<HotelLegalRepresentative<'a>>>,
    ) -> Self {
        self._fields.83 = value.into();
        self
    }
    /// Set the `legalRepresentative` field to an Option value (optional)
    pub fn maybe_legal_representative(
        mut self,
        value: Option<HotelLegalRepresentative<'a>>,
    ) -> Self {
        self._fields.83 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `leiCode` field (optional)
    pub fn lei_code(mut self, value: impl Into<Option<HotelLeiCode<'a>>>) -> Self {
        self._fields.84 = value.into();
        self
    }
    /// Set the `leiCode` field to an Option value (optional)
    pub fn maybe_lei_code(mut self, value: Option<HotelLeiCode<'a>>) -> Self {
        self._fields.84 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `location` field (optional)
    pub fn location(mut self, value: impl Into<Option<HotelLocation<'a>>>) -> Self {
        self._fields.85 = value.into();
        self
    }
    /// Set the `location` field to an Option value (optional)
    pub fn maybe_location(mut self, value: Option<HotelLocation<'a>>) -> Self {
        self._fields.85 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `logo` field (optional)
    pub fn logo(mut self, value: impl Into<Option<HotelLogo<'a>>>) -> Self {
        self._fields.86 = value.into();
        self
    }
    /// Set the `logo` field to an Option value (optional)
    pub fn maybe_logo(mut self, value: Option<HotelLogo<'a>>) -> Self {
        self._fields.86 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `longitude` field (optional)
    pub fn longitude(mut self, value: impl Into<Option<HotelLongitude<'a>>>) -> Self {
        self._fields.87 = value.into();
        self
    }
    /// Set the `longitude` field to an Option value (optional)
    pub fn maybe_longitude(mut self, value: Option<HotelLongitude<'a>>) -> Self {
        self._fields.87 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `makesOffer` field (optional)
    pub fn makes_offer(mut self, value: impl Into<Option<HotelMakesOffer<'a>>>) -> Self {
        self._fields.89 = value.into();
        self
    }
    /// Set the `makesOffer` field to an Option value (optional)
    pub fn maybe_makes_offer(mut self, value: Option<HotelMakesOffer<'a>>) -> Self {
        self._fields.89 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `map` field (optional)
    pub fn map(mut self, value: impl Into<Option<HotelMap<'a>>>) -> Self {
        self._fields.90 = value.into();
        self
    }
    /// Set the `map` field to an Option value (optional)
    pub fn maybe_map(mut self, value: Option<HotelMap<'a>>) -> Self {
        self._fields.90 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `maps` field (optional)
    pub fn maps(mut self, value: impl Into<Option<HotelMaps<'a>>>) -> Self {
        self._fields.91 = value.into();
        self
    }
    /// Set the `maps` field to an Option value (optional)
    pub fn maybe_maps(mut self, value: Option<HotelMaps<'a>>) -> Self {
        self._fields.91 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `maximumAttendeeCapacity` field (optional)
    pub fn maximum_attendee_capacity(
        mut self,
        value: impl Into<Option<HotelMaximumAttendeeCapacity<'a>>>,
    ) -> Self {
        self._fields.92 = value.into();
        self
    }
    /// Set the `maximumAttendeeCapacity` field to an Option value (optional)
    pub fn maybe_maximum_attendee_capacity(
        mut self,
        value: Option<HotelMaximumAttendeeCapacity<'a>>,
    ) -> Self {
        self._fields.92 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `member` field (optional)
    pub fn member(mut self, value: impl Into<Option<HotelMember<'a>>>) -> Self {
        self._fields.93 = value.into();
        self
    }
    /// Set the `member` field to an Option value (optional)
    pub fn maybe_member(mut self, value: Option<HotelMember<'a>>) -> Self {
        self._fields.93 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `memberOf` field (optional)
    pub fn member_of(mut self, value: impl Into<Option<HotelMemberOf<'a>>>) -> Self {
        self._fields.94 = value.into();
        self
    }
    /// Set the `memberOf` field to an Option value (optional)
    pub fn maybe_member_of(mut self, value: Option<HotelMemberOf<'a>>) -> Self {
        self._fields.94 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `members` field (optional)
    pub fn members(mut self, value: impl Into<Option<HotelMembers<'a>>>) -> Self {
        self._fields.95 = value.into();
        self
    }
    /// Set the `members` field to an Option value (optional)
    pub fn maybe_members(mut self, value: Option<HotelMembers<'a>>) -> Self {
        self._fields.95 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `naics` field (optional)
    pub fn naics(mut self, value: impl Into<Option<HotelNaics<'a>>>) -> Self {
        self._fields.96 = value.into();
        self
    }
    /// Set the `naics` field to an Option value (optional)
    pub fn maybe_naics(mut self, value: Option<HotelNaics<'a>>) -> Self {
        self._fields.96 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `nonprofitStatus` field (optional)
    pub fn nonprofit_status(
        mut self,
        value: impl Into<Option<HotelNonprofitStatus<'a>>>,
    ) -> Self {
        self._fields.98 = value.into();
        self
    }
    /// Set the `nonprofitStatus` field to an Option value (optional)
    pub fn maybe_nonprofit_status(
        mut self,
        value: Option<HotelNonprofitStatus<'a>>,
    ) -> Self {
        self._fields.98 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `numberOfEmployees` field (optional)
    pub fn number_of_employees(
        mut self,
        value: impl Into<Option<HotelNumberOfEmployees<'a>>>,
    ) -> Self {
        self._fields.99 = value.into();
        self
    }
    /// Set the `numberOfEmployees` field to an Option value (optional)
    pub fn maybe_number_of_employees(
        mut self,
        value: Option<HotelNumberOfEmployees<'a>>,
    ) -> Self {
        self._fields.99 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `numberOfRooms` field (optional)
    pub fn number_of_rooms(
        mut self,
        value: impl Into<Option<HotelNumberOfRooms<'a>>>,
    ) -> Self {
        self._fields.100 = value.into();
        self
    }
    /// Set the `numberOfRooms` field to an Option value (optional)
    pub fn maybe_number_of_rooms(
        mut self,
        value: Option<HotelNumberOfRooms<'a>>,
    ) -> Self {
        self._fields.100 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `openingHours` field (optional)
    pub fn opening_hours(
        mut self,
        value: impl Into<Option<HotelOpeningHours<'a>>>,
    ) -> Self {
        self._fields.101 = value.into();
        self
    }
    /// Set the `openingHours` field to an Option value (optional)
    pub fn maybe_opening_hours(mut self, value: Option<HotelOpeningHours<'a>>) -> Self {
        self._fields.101 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `openingHoursSpecification` field (optional)
    pub fn opening_hours_specification(
        mut self,
        value: impl Into<Option<HotelOpeningHoursSpecification<'a>>>,
    ) -> Self {
        self._fields.102 = value.into();
        self
    }
    /// Set the `openingHoursSpecification` field to an Option value (optional)
    pub fn maybe_opening_hours_specification(
        mut self,
        value: Option<HotelOpeningHoursSpecification<'a>>,
    ) -> Self {
        self._fields.102 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `ownershipFundingInfo` field (optional)
    pub fn ownership_funding_info(
        mut self,
        value: impl Into<Option<HotelOwnershipFundingInfo<'a>>>,
    ) -> Self {
        self._fields.103 = value.into();
        self
    }
    /// Set the `ownershipFundingInfo` field to an Option value (optional)
    pub fn maybe_ownership_funding_info(
        mut self,
        value: Option<HotelOwnershipFundingInfo<'a>>,
    ) -> Self {
        self._fields.103 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `owns` field (optional)
    pub fn owns(mut self, value: impl Into<Option<HotelOwns<'a>>>) -> Self {
        self._fields.104 = value.into();
        self
    }
    /// Set the `owns` field to an Option value (optional)
    pub fn maybe_owns(mut self, value: Option<HotelOwns<'a>>) -> Self {
        self._fields.104 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `parentOrganization` field (optional)
    pub fn parent_organization(
        mut self,
        value: impl Into<Option<HotelParentOrganization<'a>>>,
    ) -> Self {
        self._fields.105 = value.into();
        self
    }
    /// Set the `parentOrganization` field to an Option value (optional)
    pub fn maybe_parent_organization(
        mut self,
        value: Option<HotelParentOrganization<'a>>,
    ) -> Self {
        self._fields.105 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `paymentAccepted` field (optional)
    pub fn payment_accepted(
        mut self,
        value: impl Into<Option<HotelPaymentAccepted<'a>>>,
    ) -> Self {
        self._fields.106 = value.into();
        self
    }
    /// Set the `paymentAccepted` field to an Option value (optional)
    pub fn maybe_payment_accepted(
        mut self,
        value: Option<HotelPaymentAccepted<'a>>,
    ) -> Self {
        self._fields.106 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `petsAllowed` field (optional)
    pub fn pets_allowed(
        mut self,
        value: impl Into<Option<HotelPetsAllowed<'a>>>,
    ) -> Self {
        self._fields.107 = value.into();
        self
    }
    /// Set the `petsAllowed` field to an Option value (optional)
    pub fn maybe_pets_allowed(mut self, value: Option<HotelPetsAllowed<'a>>) -> Self {
        self._fields.107 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `photo` field (optional)
    pub fn photo(mut self, value: impl Into<Option<HotelPhoto<'a>>>) -> Self {
        self._fields.108 = value.into();
        self
    }
    /// Set the `photo` field to an Option value (optional)
    pub fn maybe_photo(mut self, value: Option<HotelPhoto<'a>>) -> Self {
        self._fields.108 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `photos` field (optional)
    pub fn photos(mut self, value: impl Into<Option<HotelPhotos<'a>>>) -> Self {
        self._fields.109 = value.into();
        self
    }
    /// Set the `photos` field to an Option value (optional)
    pub fn maybe_photos(mut self, value: Option<HotelPhotos<'a>>) -> Self {
        self._fields.109 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `priceRange` field (optional)
    pub fn price_range(mut self, value: impl Into<Option<HotelPriceRange<'a>>>) -> Self {
        self._fields.111 = value.into();
        self
    }
    /// Set the `priceRange` field to an Option value (optional)
    pub fn maybe_price_range(mut self, value: Option<HotelPriceRange<'a>>) -> Self {
        self._fields.111 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `publicAccess` field (optional)
    pub fn public_access(
        mut self,
        value: impl Into<Option<HotelPublicAccess<'a>>>,
    ) -> Self {
        self._fields.112 = value.into();
        self
    }
    /// Set the `publicAccess` field to an Option value (optional)
    pub fn maybe_public_access(mut self, value: Option<HotelPublicAccess<'a>>) -> Self {
        self._fields.112 = value;
        self
    }
}

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

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

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

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `seeks` field (optional)
    pub fn seeks(mut self, value: impl Into<Option<HotelSeeks<'a>>>) -> Self {
        self._fields.117 = value.into();
        self
    }
    /// Set the `seeks` field to an Option value (optional)
    pub fn maybe_seeks(mut self, value: Option<HotelSeeks<'a>>) -> Self {
        self._fields.117 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `serviceArea` field (optional)
    pub fn service_area(
        mut self,
        value: impl Into<Option<HotelServiceArea<'a>>>,
    ) -> Self {
        self._fields.118 = value.into();
        self
    }
    /// Set the `serviceArea` field to an Option value (optional)
    pub fn maybe_service_area(mut self, value: Option<HotelServiceArea<'a>>) -> Self {
        self._fields.118 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `skills` field (optional)
    pub fn skills(mut self, value: impl Into<Option<HotelSkills<'a>>>) -> Self {
        self._fields.119 = value.into();
        self
    }
    /// Set the `skills` field to an Option value (optional)
    pub fn maybe_skills(mut self, value: Option<HotelSkills<'a>>) -> Self {
        self._fields.119 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `slogan` field (optional)
    pub fn slogan(mut self, value: impl Into<Option<HotelSlogan<'a>>>) -> Self {
        self._fields.120 = value.into();
        self
    }
    /// Set the `slogan` field to an Option value (optional)
    pub fn maybe_slogan(mut self, value: Option<HotelSlogan<'a>>) -> Self {
        self._fields.120 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `smokingAllowed` field (optional)
    pub fn smoking_allowed(
        mut self,
        value: impl Into<Option<HotelSmokingAllowed<'a>>>,
    ) -> Self {
        self._fields.121 = value.into();
        self
    }
    /// Set the `smokingAllowed` field to an Option value (optional)
    pub fn maybe_smoking_allowed(
        mut self,
        value: Option<HotelSmokingAllowed<'a>>,
    ) -> Self {
        self._fields.121 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `specialOpeningHoursSpecification` field (optional)
    pub fn special_opening_hours_specification(
        mut self,
        value: impl Into<Option<HotelSpecialOpeningHoursSpecification<'a>>>,
    ) -> Self {
        self._fields.122 = value.into();
        self
    }
    /// Set the `specialOpeningHoursSpecification` field to an Option value (optional)
    pub fn maybe_special_opening_hours_specification(
        mut self,
        value: Option<HotelSpecialOpeningHoursSpecification<'a>>,
    ) -> Self {
        self._fields.122 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `starRating` field (optional)
    pub fn star_rating(mut self, value: impl Into<Option<HotelStarRating<'a>>>) -> Self {
        self._fields.124 = value.into();
        self
    }
    /// Set the `starRating` field to an Option value (optional)
    pub fn maybe_star_rating(mut self, value: Option<HotelStarRating<'a>>) -> Self {
        self._fields.124 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `subOrganization` field (optional)
    pub fn sub_organization(
        mut self,
        value: impl Into<Option<HotelSubOrganization<'a>>>,
    ) -> Self {
        self._fields.125 = value.into();
        self
    }
    /// Set the `subOrganization` field to an Option value (optional)
    pub fn maybe_sub_organization(
        mut self,
        value: Option<HotelSubOrganization<'a>>,
    ) -> Self {
        self._fields.125 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `taxID` field (optional)
    pub fn tax_id(mut self, value: impl Into<Option<HotelTaxId<'a>>>) -> Self {
        self._fields.127 = value.into();
        self
    }
    /// Set the `taxID` field to an Option value (optional)
    pub fn maybe_tax_id(mut self, value: Option<HotelTaxId<'a>>) -> Self {
        self._fields.127 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `telephone` field (optional)
    pub fn telephone(mut self, value: impl Into<Option<HotelTelephone<'a>>>) -> Self {
        self._fields.128 = value.into();
        self
    }
    /// Set the `telephone` field to an Option value (optional)
    pub fn maybe_telephone(mut self, value: Option<HotelTelephone<'a>>) -> Self {
        self._fields.128 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `tourBookingPage` field (optional)
    pub fn tour_booking_page(
        mut self,
        value: impl Into<Option<HotelTourBookingPage<'a>>>,
    ) -> Self {
        self._fields.129 = value.into();
        self
    }
    /// Set the `tourBookingPage` field to an Option value (optional)
    pub fn maybe_tour_booking_page(
        mut self,
        value: Option<HotelTourBookingPage<'a>>,
    ) -> Self {
        self._fields.129 = value;
        self
    }
}

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `unnamedSourcesPolicy` field (optional)
    pub fn unnamed_sources_policy(
        mut self,
        value: impl Into<Option<HotelUnnamedSourcesPolicy<'a>>>,
    ) -> Self {
        self._fields.130 = value.into();
        self
    }
    /// Set the `unnamedSourcesPolicy` field to an Option value (optional)
    pub fn maybe_unnamed_sources_policy(
        mut self,
        value: Option<HotelUnnamedSourcesPolicy<'a>>,
    ) -> Self {
        self._fields.130 = value;
        self
    }
}

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

impl<'a, S: hotel_state::State> HotelBuilder<'a, S> {
    /// Set the `vatID` field (optional)
    pub fn vat_id(mut self, value: impl Into<Option<HotelVatId<'a>>>) -> Self {
        self._fields.132 = value.into();
        self
    }
    /// Set the `vatID` field to an Option value (optional)
    pub fn maybe_vat_id(mut self, value: Option<HotelVatId<'a>>) -> Self {
        self._fields.132 = value;
        self
    }
}

impl<'a, S> HotelBuilder<'a, S>
where
    S: hotel_state::State,
{
    /// Build the final struct
    pub fn build(self) -> Hotel<'a> {
        Hotel {
            accepted_payment_method: self._fields.0,
            actionable_feedback_policy: self._fields.1,
            additional_property: self._fields.2,
            additional_type: self._fields.3,
            address: self._fields.4,
            agent_interaction_statistic: self._fields.5,
            aggregate_rating: self._fields.6,
            alternate_name: self._fields.7,
            alumni: self._fields.8,
            amenity_feature: self._fields.9,
            area_served: self._fields.10,
            audience: self._fields.11,
            available_language: self._fields.12,
            award: self._fields.13,
            awards: self._fields.14,
            branch_code: self._fields.15,
            branch_of: self._fields.16,
            brand: self._fields.17,
            checkin_time: self._fields.18,
            checkout_time: self._fields.19,
            company_registration: self._fields.20,
            contact_point: self._fields.21,
            contact_points: self._fields.22,
            contained_in: self._fields.23,
            contained_in_place: self._fields.24,
            contains_place: self._fields.25,
            corrections_policy: self._fields.26,
            currencies_accepted: self._fields.27,
            department: self._fields.28,
            description: self._fields.29,
            disambiguating_description: self._fields.30,
            dissolution_date: self._fields.31,
            diversity_policy: self._fields.32,
            diversity_staffing_report: self._fields.33,
            duns: self._fields.34,
            email: self._fields.35,
            employee: self._fields.36,
            employees: self._fields.37,
            ethics_policy: self._fields.38,
            event: self._fields.39,
            events: self._fields.40,
            fax_number: self._fields.41,
            founder: self._fields.42,
            founders: self._fields.43,
            founding_date: self._fields.44,
            founding_location: self._fields.45,
            funder: self._fields.46,
            funding: self._fields.47,
            geo: self._fields.48,
            geo_contains: self._fields.49,
            geo_covered_by: self._fields.50,
            geo_covers: self._fields.51,
            geo_crosses: self._fields.52,
            geo_disjoint: self._fields.53,
            geo_equals: self._fields.54,
            geo_intersects: self._fields.55,
            geo_overlaps: self._fields.56,
            geo_touches: self._fields.57,
            geo_within: self._fields.58,
            global_location_number: self._fields.59,
            has_certification: self._fields.60,
            has_credential: self._fields.61,
            has_drive_through_service: self._fields.62,
            has_gs1_digital_link: self._fields.63,
            has_map: self._fields.64,
            has_member_program: self._fields.65,
            has_merchant_return_policy: self._fields.66,
            has_offer_catalog: self._fields.67,
            has_pos: self._fields.68,
            has_product_return_policy: self._fields.69,
            has_shipping_service: self._fields.70,
            identifier: self._fields.71,
            image: self._fields.72,
            interaction_statistic: self._fields.73,
            is_accessible_for_free: self._fields.74,
            isic_v4: self._fields.75,
            iso6523_code: self._fields.76,
            keywords: self._fields.77,
            knows_about: self._fields.78,
            knows_language: self._fields.79,
            latitude: self._fields.80,
            legal_address: self._fields.81,
            legal_name: self._fields.82,
            legal_representative: self._fields.83,
            lei_code: self._fields.84,
            location: self._fields.85,
            logo: self._fields.86,
            longitude: self._fields.87,
            main_entity_of_page: self._fields.88,
            makes_offer: self._fields.89,
            map: self._fields.90,
            maps: self._fields.91,
            maximum_attendee_capacity: self._fields.92,
            member: self._fields.93,
            member_of: self._fields.94,
            members: self._fields.95,
            naics: self._fields.96,
            name: self._fields.97,
            nonprofit_status: self._fields.98,
            number_of_employees: self._fields.99,
            number_of_rooms: self._fields.100,
            opening_hours: self._fields.101,
            opening_hours_specification: self._fields.102,
            ownership_funding_info: self._fields.103,
            owns: self._fields.104,
            parent_organization: self._fields.105,
            payment_accepted: self._fields.106,
            pets_allowed: self._fields.107,
            photo: self._fields.108,
            photos: self._fields.109,
            potential_action: self._fields.110,
            price_range: self._fields.111,
            public_access: self._fields.112,
            publishing_principles: self._fields.113,
            review: self._fields.114,
            reviews: self._fields.115,
            same_as: self._fields.116,
            seeks: self._fields.117,
            service_area: self._fields.118,
            skills: self._fields.119,
            slogan: self._fields.120,
            smoking_allowed: self._fields.121,
            special_opening_hours_specification: self._fields.122,
            sponsor: self._fields.123,
            star_rating: self._fields.124,
            sub_organization: self._fields.125,
            subject_of: self._fields.126,
            tax_id: self._fields.127,
            telephone: self._fields.128,
            tour_booking_page: self._fields.129,
            unnamed_sources_policy: self._fields.130,
            url: self._fields.131,
            vat_id: self._fields.132,
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data
    pub fn build_with_data(
        self,
        extra_data: BTreeMap<jacquard_common::deps::smol_str::SmolStr, Data<'a>>,
    ) -> Hotel<'a> {
        Hotel {
            accepted_payment_method: self._fields.0,
            actionable_feedback_policy: self._fields.1,
            additional_property: self._fields.2,
            additional_type: self._fields.3,
            address: self._fields.4,
            agent_interaction_statistic: self._fields.5,
            aggregate_rating: self._fields.6,
            alternate_name: self._fields.7,
            alumni: self._fields.8,
            amenity_feature: self._fields.9,
            area_served: self._fields.10,
            audience: self._fields.11,
            available_language: self._fields.12,
            award: self._fields.13,
            awards: self._fields.14,
            branch_code: self._fields.15,
            branch_of: self._fields.16,
            brand: self._fields.17,
            checkin_time: self._fields.18,
            checkout_time: self._fields.19,
            company_registration: self._fields.20,
            contact_point: self._fields.21,
            contact_points: self._fields.22,
            contained_in: self._fields.23,
            contained_in_place: self._fields.24,
            contains_place: self._fields.25,
            corrections_policy: self._fields.26,
            currencies_accepted: self._fields.27,
            department: self._fields.28,
            description: self._fields.29,
            disambiguating_description: self._fields.30,
            dissolution_date: self._fields.31,
            diversity_policy: self._fields.32,
            diversity_staffing_report: self._fields.33,
            duns: self._fields.34,
            email: self._fields.35,
            employee: self._fields.36,
            employees: self._fields.37,
            ethics_policy: self._fields.38,
            event: self._fields.39,
            events: self._fields.40,
            fax_number: self._fields.41,
            founder: self._fields.42,
            founders: self._fields.43,
            founding_date: self._fields.44,
            founding_location: self._fields.45,
            funder: self._fields.46,
            funding: self._fields.47,
            geo: self._fields.48,
            geo_contains: self._fields.49,
            geo_covered_by: self._fields.50,
            geo_covers: self._fields.51,
            geo_crosses: self._fields.52,
            geo_disjoint: self._fields.53,
            geo_equals: self._fields.54,
            geo_intersects: self._fields.55,
            geo_overlaps: self._fields.56,
            geo_touches: self._fields.57,
            geo_within: self._fields.58,
            global_location_number: self._fields.59,
            has_certification: self._fields.60,
            has_credential: self._fields.61,
            has_drive_through_service: self._fields.62,
            has_gs1_digital_link: self._fields.63,
            has_map: self._fields.64,
            has_member_program: self._fields.65,
            has_merchant_return_policy: self._fields.66,
            has_offer_catalog: self._fields.67,
            has_pos: self._fields.68,
            has_product_return_policy: self._fields.69,
            has_shipping_service: self._fields.70,
            identifier: self._fields.71,
            image: self._fields.72,
            interaction_statistic: self._fields.73,
            is_accessible_for_free: self._fields.74,
            isic_v4: self._fields.75,
            iso6523_code: self._fields.76,
            keywords: self._fields.77,
            knows_about: self._fields.78,
            knows_language: self._fields.79,
            latitude: self._fields.80,
            legal_address: self._fields.81,
            legal_name: self._fields.82,
            legal_representative: self._fields.83,
            lei_code: self._fields.84,
            location: self._fields.85,
            logo: self._fields.86,
            longitude: self._fields.87,
            main_entity_of_page: self._fields.88,
            makes_offer: self._fields.89,
            map: self._fields.90,
            maps: self._fields.91,
            maximum_attendee_capacity: self._fields.92,
            member: self._fields.93,
            member_of: self._fields.94,
            members: self._fields.95,
            naics: self._fields.96,
            name: self._fields.97,
            nonprofit_status: self._fields.98,
            number_of_employees: self._fields.99,
            number_of_rooms: self._fields.100,
            opening_hours: self._fields.101,
            opening_hours_specification: self._fields.102,
            ownership_funding_info: self._fields.103,
            owns: self._fields.104,
            parent_organization: self._fields.105,
            payment_accepted: self._fields.106,
            pets_allowed: self._fields.107,
            photo: self._fields.108,
            photos: self._fields.109,
            potential_action: self._fields.110,
            price_range: self._fields.111,
            public_access: self._fields.112,
            publishing_principles: self._fields.113,
            review: self._fields.114,
            reviews: self._fields.115,
            same_as: self._fields.116,
            seeks: self._fields.117,
            service_area: self._fields.118,
            skills: self._fields.119,
            slogan: self._fields.120,
            smoking_allowed: self._fields.121,
            special_opening_hours_specification: self._fields.122,
            sponsor: self._fields.123,
            star_rating: self._fields.124,
            sub_organization: self._fields.125,
            subject_of: self._fields.126,
            tax_id: self._fields.127,
            telephone: self._fields.128,
            tour_booking_page: self._fields.129,
            unnamed_sources_policy: self._fields.130,
            url: self._fields.131,
            vat_id: self._fields.132,
            extra_data: Some(extra_data),
        }
    }
}