jacquard-api 0.11.0

// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: games.gamesgamesgamesgames.defs
//
// This file was automatically generated from Lexicon schemas.
// Any manual changes will be overwritten on the next regeneration.

pub mod actor;
pub mod claim;
pub mod claim_review;
pub mod collection;
pub mod create_claim;
pub mod create_game;
pub mod engine;
pub mod feed;
pub mod game;
pub mod get_claim;
pub mod get_game;
pub mod get_profile;
pub mod get_reviews;
pub mod graph;
pub mod list_claims;
pub mod list_games;
pub mod list_org_games;
pub mod migrate_claim;
pub mod org;
pub mod platform;
pub mod platform_family;
pub mod put_game;
pub mod redirect;
pub mod review_claim;
pub mod richtext;
pub mod search;
pub mod search_profiles_typeahead;
pub mod search_slugs;
pub mod slug;


#[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::blob::BlobRef;
use jacquard_common::types::string::{Did, AtUri, Datetime, UriValue};
use jacquard_derive::{IntoStatic, lexicon};
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::app_bsky::richtext::facet::Facet;
use crate::games_gamesgamesgamesgames;

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct ActorCreditView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub actor_uri: Option<AtUri<'a>>,
    #[serde(borrow)]
    pub credits: Vec<games_gamesgamesgamesgames::CreditEntry<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub display_name: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct ActorProfileDetailView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub avatar: Option<BlobRef<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_at: Option<Datetime>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description_facets: Option<Vec<Facet<'a>>>,
    #[serde(borrow)]
    pub did: Did<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub display_name: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub pronouns: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub websites: Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct ActorProfileSummaryView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub avatar: Option<BlobRef<'a>>,
    #[serde(borrow)]
    pub did: Did<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub display_name: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct AgeRating<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub content_descriptors: Option<Vec<CowStr<'a>>>,
    #[serde(borrow)]
    pub organization: AgeRatingOrganization<'a>,
    #[serde(borrow)]
    pub rating: CowStr<'a>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AgeRatingOrganization<'a> {
    Esrb,
    Pegi,
    Cero,
    Usk,
    Grac,
    ClassInd,
    Acb,
    Other(CowStr<'a>),
}

impl<'a> AgeRatingOrganization<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Esrb => "esrb",
            Self::Pegi => "pegi",
            Self::Cero => "cero",
            Self::Usk => "usk",
            Self::Grac => "grac",
            Self::ClassInd => "classInd",
            Self::Acb => "acb",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for AgeRatingOrganization<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "esrb" => Self::Esrb,
            "pegi" => Self::Pegi,
            "cero" => Self::Cero,
            "usk" => Self::Usk,
            "grac" => Self::Grac,
            "classInd" => Self::ClassInd,
            "acb" => Self::Acb,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for AgeRatingOrganization<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "esrb" => Self::Esrb,
            "pegi" => Self::Pegi,
            "cero" => Self::Cero,
            "usk" => Self::Usk,
            "grac" => Self::Grac,
            "classInd" => Self::ClassInd,
            "acb" => Self::Acb,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for AgeRatingOrganization<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for AgeRatingOrganization<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for AgeRatingOrganization<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for AgeRatingOrganization<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for AgeRatingOrganization<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for AgeRatingOrganization<'_> {
    type Output = AgeRatingOrganization<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            AgeRatingOrganization::Esrb => AgeRatingOrganization::Esrb,
            AgeRatingOrganization::Pegi => AgeRatingOrganization::Pegi,
            AgeRatingOrganization::Cero => AgeRatingOrganization::Cero,
            AgeRatingOrganization::Usk => AgeRatingOrganization::Usk,
            AgeRatingOrganization::Grac => AgeRatingOrganization::Grac,
            AgeRatingOrganization::ClassInd => AgeRatingOrganization::ClassInd,
            AgeRatingOrganization::Acb => AgeRatingOrganization::Acb,
            AgeRatingOrganization::Other(v) => {
                AgeRatingOrganization::Other(v.into_static())
            }
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct AlternativeName<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub comment: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub locale: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub name: CowStr<'a>,
}

pub type ApplicationType<'a> = CowStr<'a>;

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct CollectionSummaryView<'a> {
    #[serde(borrow)]
    pub name: CowStr<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub slug: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub r#type: Option<CollectionSummaryViewType<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum CollectionSummaryViewType<'a> {
    Franchise,
    Series,
    Curated,
    Other(CowStr<'a>),
}

impl<'a> CollectionSummaryViewType<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Franchise => "franchise",
            Self::Series => "series",
            Self::Curated => "curated",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for CollectionSummaryViewType<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "franchise" => Self::Franchise,
            "series" => Self::Series,
            "curated" => Self::Curated,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for CollectionSummaryViewType<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "franchise" => Self::Franchise,
            "series" => Self::Series,
            "curated" => Self::Curated,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for CollectionSummaryViewType<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for CollectionSummaryViewType<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for CollectionSummaryViewType<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for CollectionSummaryViewType<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for CollectionSummaryViewType<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for CollectionSummaryViewType<'_> {
    type Output = CollectionSummaryViewType<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            CollectionSummaryViewType::Franchise => CollectionSummaryViewType::Franchise,
            CollectionSummaryViewType::Series => CollectionSummaryViewType::Series,
            CollectionSummaryViewType::Curated => CollectionSummaryViewType::Curated,
            CollectionSummaryViewType::Other(v) => {
                CollectionSummaryViewType::Other(v.into_static())
            }
        }
    }
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum CompanyRole<'a> {
    Developer,
    Publisher,
    Porter,
    Supporter,
    Other(CowStr<'a>),
}

impl<'a> CompanyRole<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Developer => "developer",
            Self::Publisher => "publisher",
            Self::Porter => "porter",
            Self::Supporter => "supporter",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for CompanyRole<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "developer" => Self::Developer,
            "publisher" => Self::Publisher,
            "porter" => Self::Porter,
            "supporter" => Self::Supporter,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for CompanyRole<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "developer" => Self::Developer,
            "publisher" => Self::Publisher,
            "porter" => Self::Porter,
            "supporter" => Self::Supporter,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> AsRef<str> for CompanyRole<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> core::fmt::Display for CompanyRole<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> serde::Serialize for CompanyRole<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for CompanyRole<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl jacquard_common::IntoStatic for CompanyRole<'_> {
    type Output = CompanyRole<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            CompanyRole::Developer => CompanyRole::Developer,
            CompanyRole::Publisher => CompanyRole::Publisher,
            CompanyRole::Porter => CompanyRole::Porter,
            CompanyRole::Supporter => CompanyRole::Supporter,
            CompanyRole::Other(v) => CompanyRole::Other(v.into_static()),
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct CreditEntry<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub department: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub role: games_gamesgamesgamesgames::IndividualRole<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct EngineSummaryView<'a> {
    #[serde(borrow)]
    pub name: CowStr<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub slug: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct ExternalIds<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub apple_app_store: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub epic_games: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub gog: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub google_play: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub humble_bundle: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub igdb: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub itch_io: Option<games_gamesgamesgamesgames::ItchIoId<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub nintendo_eshop: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub play_station: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub steam: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub twitch: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub xbox: Option<CowStr<'a>>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct ExternalVideo<'a> {
    #[serde(borrow)]
    pub platform: ExternalVideoPlatform<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub title: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub video_id: CowStr<'a>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ExternalVideoPlatform<'a> {
    Youtube,
    Twitch,
    Vimeo,
    Other(CowStr<'a>),
}

impl<'a> ExternalVideoPlatform<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Youtube => "youtube",
            Self::Twitch => "twitch",
            Self::Vimeo => "vimeo",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for ExternalVideoPlatform<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "youtube" => Self::Youtube,
            "twitch" => Self::Twitch,
            "vimeo" => Self::Vimeo,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for ExternalVideoPlatform<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "youtube" => Self::Youtube,
            "twitch" => Self::Twitch,
            "vimeo" => Self::Vimeo,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for ExternalVideoPlatform<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for ExternalVideoPlatform<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for ExternalVideoPlatform<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for ExternalVideoPlatform<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for ExternalVideoPlatform<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for ExternalVideoPlatform<'_> {
    type Output = ExternalVideoPlatform<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            ExternalVideoPlatform::Youtube => ExternalVideoPlatform::Youtube,
            ExternalVideoPlatform::Twitch => ExternalVideoPlatform::Twitch,
            ExternalVideoPlatform::Vimeo => ExternalVideoPlatform::Vimeo,
            ExternalVideoPlatform::Other(v) => {
                ExternalVideoPlatform::Other(v.into_static())
            }
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct GameDetailView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub actor_credits: Option<Vec<games_gamesgamesgamesgames::ActorCreditView<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub age_ratings: Option<Vec<games_gamesgamesgamesgames::AgeRating<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub alternative_names: Option<Vec<games_gamesgamesgamesgames::AlternativeName<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub application_type: Option<games_gamesgamesgamesgames::ApplicationType<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub collections: Option<Vec<AtUri<'a>>>,
    pub created_at: Datetime,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub engines: Option<Vec<AtUri<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub external_ids: Option<games_gamesgamesgamesgames::ExternalIds<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub genres: Option<Vec<games_gamesgamesgamesgames::Genre<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub keywords: Option<Vec<CowStr<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub language_supports: Option<Vec<games_gamesgamesgamesgames::LanguageSupport<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub media: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub modes: Option<Vec<games_gamesgamesgamesgames::Mode<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub multiplayer_modes: Option<Vec<games_gamesgamesgamesgames::MultiplayerMode<'a>>>,
    #[serde(borrow)]
    pub name: CowStr<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub org_credits: Option<Vec<games_gamesgamesgamesgames::OrgCreditView<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub parent: Option<AtUri<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub player_perspectives: Option<
        Vec<games_gamesgamesgamesgames::PlayerPerspective<'a>>,
    >,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub published_at: Option<Datetime>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub releases: Option<Vec<games_gamesgamesgamesgames::Release<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub slug: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub storyline: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub summary: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub themes: Option<Vec<games_gamesgamesgamesgames::Theme<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub time_to_beat: Option<games_gamesgamesgamesgames::TimeToBeat<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub videos: Option<Vec<games_gamesgamesgamesgames::ExternalVideo<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub websites: Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct GameFeedViewItem<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub feed_context: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub game: games_gamesgamesgamesgames::GameView<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct GameSummaryView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub application_type: Option<games_gamesgamesgamesgames::ApplicationType<'a>>,
    ///Earliest release date as YYYYMMDD integer.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub first_release_date: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub media: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    #[serde(borrow)]
    pub name: CowStr<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub slug: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub summary: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct GameView<'a> {
    #[serde(borrow)]
    pub application_type: games_gamesgamesgamesgames::ApplicationType<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub genres: Option<Vec<games_gamesgamesgamesgames::Genre<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub like_count: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub media: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    #[serde(borrow)]
    pub name: CowStr<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub releases: Option<Vec<games_gamesgamesgamesgames::Release<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub slug: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub summary: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub themes: Option<Vec<games_gamesgamesgamesgames::Theme<'a>>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub viewer: Option<games_gamesgamesgamesgames::ViewerState<'a>>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Genre<'a> {
    Fighting,
    Music,
    Platform,
    PointAndClick,
    Puzzle,
    Racing,
    Rpg,
    Rts,
    Shooter,
    Simulator,
    Other(CowStr<'a>),
}

impl<'a> Genre<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Fighting => "fighting",
            Self::Music => "music",
            Self::Platform => "platform",
            Self::PointAndClick => "pointAndClick",
            Self::Puzzle => "puzzle",
            Self::Racing => "racing",
            Self::Rpg => "rpg",
            Self::Rts => "rts",
            Self::Shooter => "shooter",
            Self::Simulator => "simulator",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for Genre<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "fighting" => Self::Fighting,
            "music" => Self::Music,
            "platform" => Self::Platform,
            "pointAndClick" => Self::PointAndClick,
            "puzzle" => Self::Puzzle,
            "racing" => Self::Racing,
            "rpg" => Self::Rpg,
            "rts" => Self::Rts,
            "shooter" => Self::Shooter,
            "simulator" => Self::Simulator,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for Genre<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "fighting" => Self::Fighting,
            "music" => Self::Music,
            "platform" => Self::Platform,
            "pointAndClick" => Self::PointAndClick,
            "puzzle" => Self::Puzzle,
            "racing" => Self::Racing,
            "rpg" => Self::Rpg,
            "rts" => Self::Rts,
            "shooter" => Self::Shooter,
            "simulator" => Self::Simulator,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> AsRef<str> for Genre<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> core::fmt::Display for Genre<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> serde::Serialize for Genre<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for Genre<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl jacquard_common::IntoStatic for Genre<'_> {
    type Output = Genre<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            Genre::Fighting => Genre::Fighting,
            Genre::Music => Genre::Music,
            Genre::Platform => Genre::Platform,
            Genre::PointAndClick => Genre::PointAndClick,
            Genre::Puzzle => Genre::Puzzle,
            Genre::Racing => Genre::Racing,
            Genre::Rpg => Genre::Rpg,
            Genre::Rts => Genre::Rts,
            Genre::Shooter => Genre::Shooter,
            Genre::Simulator => Genre::Simulator,
            Genre::Other(v) => Genre::Other(v.into_static()),
        }
    }
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum IndividualRole<'a> {
    Director,
    Producer,
    Designer,
    Programmer,
    Artist,
    Animator,
    Writer,
    Composer,
    SoundDesigner,
    VoiceActor,
    Qa,
    Localization,
    CommunityManager,
    Marketing,
    Other(CowStr<'a>),
}

impl<'a> IndividualRole<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Director => "director",
            Self::Producer => "producer",
            Self::Designer => "designer",
            Self::Programmer => "programmer",
            Self::Artist => "artist",
            Self::Animator => "animator",
            Self::Writer => "writer",
            Self::Composer => "composer",
            Self::SoundDesigner => "soundDesigner",
            Self::VoiceActor => "voiceActor",
            Self::Qa => "qa",
            Self::Localization => "localization",
            Self::CommunityManager => "communityManager",
            Self::Marketing => "marketing",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for IndividualRole<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "director" => Self::Director,
            "producer" => Self::Producer,
            "designer" => Self::Designer,
            "programmer" => Self::Programmer,
            "artist" => Self::Artist,
            "animator" => Self::Animator,
            "writer" => Self::Writer,
            "composer" => Self::Composer,
            "soundDesigner" => Self::SoundDesigner,
            "voiceActor" => Self::VoiceActor,
            "qa" => Self::Qa,
            "localization" => Self::Localization,
            "communityManager" => Self::CommunityManager,
            "marketing" => Self::Marketing,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for IndividualRole<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "director" => Self::Director,
            "producer" => Self::Producer,
            "designer" => Self::Designer,
            "programmer" => Self::Programmer,
            "artist" => Self::Artist,
            "animator" => Self::Animator,
            "writer" => Self::Writer,
            "composer" => Self::Composer,
            "soundDesigner" => Self::SoundDesigner,
            "voiceActor" => Self::VoiceActor,
            "qa" => Self::Qa,
            "localization" => Self::Localization,
            "communityManager" => Self::CommunityManager,
            "marketing" => Self::Marketing,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> AsRef<str> for IndividualRole<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> core::fmt::Display for IndividualRole<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> serde::Serialize for IndividualRole<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for IndividualRole<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl jacquard_common::IntoStatic for IndividualRole<'_> {
    type Output = IndividualRole<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            IndividualRole::Director => IndividualRole::Director,
            IndividualRole::Producer => IndividualRole::Producer,
            IndividualRole::Designer => IndividualRole::Designer,
            IndividualRole::Programmer => IndividualRole::Programmer,
            IndividualRole::Artist => IndividualRole::Artist,
            IndividualRole::Animator => IndividualRole::Animator,
            IndividualRole::Writer => IndividualRole::Writer,
            IndividualRole::Composer => IndividualRole::Composer,
            IndividualRole::SoundDesigner => IndividualRole::SoundDesigner,
            IndividualRole::VoiceActor => IndividualRole::VoiceActor,
            IndividualRole::Qa => IndividualRole::Qa,
            IndividualRole::Localization => IndividualRole::Localization,
            IndividualRole::CommunityManager => IndividualRole::CommunityManager,
            IndividualRole::Marketing => IndividualRole::Marketing,
            IndividualRole::Other(v) => IndividualRole::Other(v.into_static()),
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct ItchIoId<'a> {
    #[serde(borrow)]
    pub developer: CowStr<'a>,
    #[serde(borrow)]
    pub game: CowStr<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct LanguageSupport<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audio: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interface: Option<bool>,
    #[serde(borrow)]
    pub language: CowStr<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subtitles: Option<bool>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct MediaItem<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub blob: Option<BlobRef<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub height: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub locale: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub media_type: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub title: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub width: Option<i64>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Mode<'a> {
    BattleRoyale,
    Cooperative,
    Mmo,
    Multiplayer,
    SinglePlayer,
    SplitScreen,
    Other(CowStr<'a>),
}

impl<'a> Mode<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::BattleRoyale => "battleRoyale",
            Self::Cooperative => "cooperative",
            Self::Mmo => "mmo",
            Self::Multiplayer => "multiplayer",
            Self::SinglePlayer => "singlePlayer",
            Self::SplitScreen => "splitScreen",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for Mode<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "battleRoyale" => Self::BattleRoyale,
            "cooperative" => Self::Cooperative,
            "mmo" => Self::Mmo,
            "multiplayer" => Self::Multiplayer,
            "singlePlayer" => Self::SinglePlayer,
            "splitScreen" => Self::SplitScreen,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for Mode<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "battleRoyale" => Self::BattleRoyale,
            "cooperative" => Self::Cooperative,
            "mmo" => Self::Mmo,
            "multiplayer" => Self::Multiplayer,
            "singlePlayer" => Self::SinglePlayer,
            "splitScreen" => Self::SplitScreen,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> AsRef<str> for Mode<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> core::fmt::Display for Mode<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> serde::Serialize for Mode<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for Mode<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl jacquard_common::IntoStatic for Mode<'_> {
    type Output = Mode<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            Mode::BattleRoyale => Mode::BattleRoyale,
            Mode::Cooperative => Mode::Cooperative,
            Mode::Mmo => Mode::Mmo,
            Mode::Multiplayer => Mode::Multiplayer,
            Mode::SinglePlayer => Mode::SinglePlayer,
            Mode::SplitScreen => Mode::SplitScreen,
            Mode::Other(v) => Mode::Other(v.into_static()),
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct MultiplayerMode<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_campaign_coop: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_drop_in: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_lan_coop: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_splitscreen: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub has_splitscreen_online: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_coop_max: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offline_max: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub online_coop_max: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub online_max: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub platform: Option<CowStr<'a>>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct OrgCreditView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub display_name: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub org_uri: Option<AtUri<'a>>,
    #[serde(borrow)]
    pub roles: Vec<games_gamesgamesgamesgames::CompanyRole<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct OrgProfileDetailView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub avatar: Option<BlobRef<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub country: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_at: Option<Datetime>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub description_facets: Option<Vec<Facet<'a>>>,
    #[serde(borrow)]
    pub did: Did<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub display_name: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub founded_at: Option<Datetime>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub media: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub parent: Option<AtUri<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub status: Option<OrgProfileDetailViewStatus<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub websites: Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum OrgProfileDetailViewStatus<'a> {
    Active,
    Inactive,
    Merged,
    Acquired,
    Defunct,
    Other(CowStr<'a>),
}

impl<'a> OrgProfileDetailViewStatus<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Inactive => "inactive",
            Self::Merged => "merged",
            Self::Acquired => "acquired",
            Self::Defunct => "defunct",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for OrgProfileDetailViewStatus<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "active" => Self::Active,
            "inactive" => Self::Inactive,
            "merged" => Self::Merged,
            "acquired" => Self::Acquired,
            "defunct" => Self::Defunct,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for OrgProfileDetailViewStatus<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "active" => Self::Active,
            "inactive" => Self::Inactive,
            "merged" => Self::Merged,
            "acquired" => Self::Acquired,
            "defunct" => Self::Defunct,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for OrgProfileDetailViewStatus<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for OrgProfileDetailViewStatus<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for OrgProfileDetailViewStatus<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for OrgProfileDetailViewStatus<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for OrgProfileDetailViewStatus<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for OrgProfileDetailViewStatus<'_> {
    type Output = OrgProfileDetailViewStatus<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            OrgProfileDetailViewStatus::Active => OrgProfileDetailViewStatus::Active,
            OrgProfileDetailViewStatus::Inactive => OrgProfileDetailViewStatus::Inactive,
            OrgProfileDetailViewStatus::Merged => OrgProfileDetailViewStatus::Merged,
            OrgProfileDetailViewStatus::Acquired => OrgProfileDetailViewStatus::Acquired,
            OrgProfileDetailViewStatus::Defunct => OrgProfileDetailViewStatus::Defunct,
            OrgProfileDetailViewStatus::Other(v) => {
                OrgProfileDetailViewStatus::Other(v.into_static())
            }
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct OrgProfileSummaryView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub avatar: Option<BlobRef<'a>>,
    #[serde(borrow)]
    pub did: Did<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub display_name: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PlatformCategory<'a> {
    Console,
    Portable,
    Computer,
    Arcade,
    OperatingSystem,
    Other(CowStr<'a>),
}

impl<'a> PlatformCategory<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Console => "console",
            Self::Portable => "portable",
            Self::Computer => "computer",
            Self::Arcade => "arcade",
            Self::OperatingSystem => "operatingSystem",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for PlatformCategory<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "console" => Self::Console,
            "portable" => Self::Portable,
            "computer" => Self::Computer,
            "arcade" => Self::Arcade,
            "operatingSystem" => Self::OperatingSystem,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for PlatformCategory<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "console" => Self::Console,
            "portable" => Self::Portable,
            "computer" => Self::Computer,
            "arcade" => Self::Arcade,
            "operatingSystem" => Self::OperatingSystem,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> AsRef<str> for PlatformCategory<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> core::fmt::Display for PlatformCategory<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> serde::Serialize for PlatformCategory<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for PlatformCategory<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl jacquard_common::IntoStatic for PlatformCategory<'_> {
    type Output = PlatformCategory<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            PlatformCategory::Console => PlatformCategory::Console,
            PlatformCategory::Portable => PlatformCategory::Portable,
            PlatformCategory::Computer => PlatformCategory::Computer,
            PlatformCategory::Arcade => PlatformCategory::Arcade,
            PlatformCategory::OperatingSystem => PlatformCategory::OperatingSystem,
            PlatformCategory::Other(v) => PlatformCategory::Other(v.into_static()),
        }
    }
}

/// Features supported by a game on a specific storefront/platform.

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct PlatformFeatures<'a> {
    #[serde(borrow)]
    pub features: Vec<CowStr<'a>>,
    #[serde(borrow)]
    pub platform: PlatformFeaturesPlatform<'a>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PlatformFeaturesPlatform<'a> {
    Steam,
    Gog,
    EpicGames,
    PlayStation,
    Xbox,
    NintendoEshop,
    Other(CowStr<'a>),
}

impl<'a> PlatformFeaturesPlatform<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Steam => "steam",
            Self::Gog => "gog",
            Self::EpicGames => "epicGames",
            Self::PlayStation => "playStation",
            Self::Xbox => "xbox",
            Self::NintendoEshop => "nintendoEshop",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for PlatformFeaturesPlatform<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "steam" => Self::Steam,
            "gog" => Self::Gog,
            "epicGames" => Self::EpicGames,
            "playStation" => Self::PlayStation,
            "xbox" => Self::Xbox,
            "nintendoEshop" => Self::NintendoEshop,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for PlatformFeaturesPlatform<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "steam" => Self::Steam,
            "gog" => Self::Gog,
            "epicGames" => Self::EpicGames,
            "playStation" => Self::PlayStation,
            "xbox" => Self::Xbox,
            "nintendoEshop" => Self::NintendoEshop,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for PlatformFeaturesPlatform<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for PlatformFeaturesPlatform<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for PlatformFeaturesPlatform<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for PlatformFeaturesPlatform<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for PlatformFeaturesPlatform<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for PlatformFeaturesPlatform<'_> {
    type Output = PlatformFeaturesPlatform<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            PlatformFeaturesPlatform::Steam => PlatformFeaturesPlatform::Steam,
            PlatformFeaturesPlatform::Gog => PlatformFeaturesPlatform::Gog,
            PlatformFeaturesPlatform::EpicGames => PlatformFeaturesPlatform::EpicGames,
            PlatformFeaturesPlatform::PlayStation => {
                PlatformFeaturesPlatform::PlayStation
            }
            PlatformFeaturesPlatform::Xbox => PlatformFeaturesPlatform::Xbox,
            PlatformFeaturesPlatform::NintendoEshop => {
                PlatformFeaturesPlatform::NintendoEshop
            }
            PlatformFeaturesPlatform::Other(v) => {
                PlatformFeaturesPlatform::Other(v.into_static())
            }
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct PlatformSummaryView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub abbreviation: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub category: Option<games_gamesgamesgamesgames::PlatformCategory<'a>>,
    #[serde(borrow)]
    pub name: CowStr<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub slug: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct PlatformVersion<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub connectivity: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub cpu: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub gpu: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub max_resolution: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub media: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub memory: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub name: CowStr<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub os: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub output: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub storage: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub summary: Option<CowStr<'a>>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PlayerPerspective<'a> {
    Auditory,
    FirstPerson,
    Isometric,
    SideView,
    Text,
    ThirdPerson,
    TopDown,
    Vr,
    Other(CowStr<'a>),
}

impl<'a> PlayerPerspective<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Auditory => "auditory",
            Self::FirstPerson => "firstPerson",
            Self::Isometric => "isometric",
            Self::SideView => "sideView",
            Self::Text => "text",
            Self::ThirdPerson => "thirdPerson",
            Self::TopDown => "topDown",
            Self::Vr => "vr",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for PlayerPerspective<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "auditory" => Self::Auditory,
            "firstPerson" => Self::FirstPerson,
            "isometric" => Self::Isometric,
            "sideView" => Self::SideView,
            "text" => Self::Text,
            "thirdPerson" => Self::ThirdPerson,
            "topDown" => Self::TopDown,
            "vr" => Self::Vr,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for PlayerPerspective<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "auditory" => Self::Auditory,
            "firstPerson" => Self::FirstPerson,
            "isometric" => Self::Isometric,
            "sideView" => Self::SideView,
            "text" => Self::Text,
            "thirdPerson" => Self::ThirdPerson,
            "topDown" => Self::TopDown,
            "vr" => Self::Vr,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> AsRef<str> for PlayerPerspective<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> core::fmt::Display for PlayerPerspective<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> serde::Serialize for PlayerPerspective<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for PlayerPerspective<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl jacquard_common::IntoStatic for PlayerPerspective<'_> {
    type Output = PlayerPerspective<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            PlayerPerspective::Auditory => PlayerPerspective::Auditory,
            PlayerPerspective::FirstPerson => PlayerPerspective::FirstPerson,
            PlayerPerspective::Isometric => PlayerPerspective::Isometric,
            PlayerPerspective::SideView => PlayerPerspective::SideView,
            PlayerPerspective::Text => PlayerPerspective::Text,
            PlayerPerspective::ThirdPerson => PlayerPerspective::ThirdPerson,
            PlayerPerspective::TopDown => PlayerPerspective::TopDown,
            PlayerPerspective::Vr => PlayerPerspective::Vr,
            PlayerPerspective::Other(v) => PlayerPerspective::Other(v.into_static()),
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct ProfileSummaryView<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub avatar: Option<BlobRef<'a>>,
    #[serde(borrow)]
    pub did: Did<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub display_name: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub profile_type: ProfileSummaryViewProfileType<'a>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ProfileSummaryViewProfileType<'a> {
    Actor,
    Org,
    Other(CowStr<'a>),
}

impl<'a> ProfileSummaryViewProfileType<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Actor => "actor",
            Self::Org => "org",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for ProfileSummaryViewProfileType<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "actor" => Self::Actor,
            "org" => Self::Org,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for ProfileSummaryViewProfileType<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "actor" => Self::Actor,
            "org" => Self::Org,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for ProfileSummaryViewProfileType<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for ProfileSummaryViewProfileType<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for ProfileSummaryViewProfileType<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for ProfileSummaryViewProfileType<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for ProfileSummaryViewProfileType<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for ProfileSummaryViewProfileType<'_> {
    type Output = ProfileSummaryViewProfileType<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            ProfileSummaryViewProfileType::Actor => ProfileSummaryViewProfileType::Actor,
            ProfileSummaryViewProfileType::Org => ProfileSummaryViewProfileType::Org,
            ProfileSummaryViewProfileType::Other(v) => {
                ProfileSummaryViewProfileType::Other(v.into_static())
            }
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct Release<'a> {
    ///Free-text platform name, used when no platform record exists.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub platform: Option<CowStr<'a>>,
    ///AT URI of a platform record.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub platform_uri: Option<AtUri<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub release_dates: Option<Vec<games_gamesgamesgamesgames::ReleaseDate<'a>>>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct ReleaseDate<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub region: Option<ReleaseDateRegion<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub released_at: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub released_at_format: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub status: Option<ReleaseDateStatus<'a>>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ReleaseDateRegion<'a> {
    Worldwide,
    Europe,
    NorthAmerica,
    Australia,
    NewZealand,
    Japan,
    China,
    Asia,
    Korea,
    Brazil,
    Other(CowStr<'a>),
}

impl<'a> ReleaseDateRegion<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Worldwide => "worldwide",
            Self::Europe => "europe",
            Self::NorthAmerica => "northAmerica",
            Self::Australia => "australia",
            Self::NewZealand => "newZealand",
            Self::Japan => "japan",
            Self::China => "china",
            Self::Asia => "asia",
            Self::Korea => "korea",
            Self::Brazil => "brazil",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for ReleaseDateRegion<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "worldwide" => Self::Worldwide,
            "europe" => Self::Europe,
            "northAmerica" => Self::NorthAmerica,
            "australia" => Self::Australia,
            "newZealand" => Self::NewZealand,
            "japan" => Self::Japan,
            "china" => Self::China,
            "asia" => Self::Asia,
            "korea" => Self::Korea,
            "brazil" => Self::Brazil,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for ReleaseDateRegion<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "worldwide" => Self::Worldwide,
            "europe" => Self::Europe,
            "northAmerica" => Self::NorthAmerica,
            "australia" => Self::Australia,
            "newZealand" => Self::NewZealand,
            "japan" => Self::Japan,
            "china" => Self::China,
            "asia" => Self::Asia,
            "korea" => Self::Korea,
            "brazil" => Self::Brazil,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for ReleaseDateRegion<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for ReleaseDateRegion<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for ReleaseDateRegion<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for ReleaseDateRegion<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for ReleaseDateRegion<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for ReleaseDateRegion<'_> {
    type Output = ReleaseDateRegion<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            ReleaseDateRegion::Worldwide => ReleaseDateRegion::Worldwide,
            ReleaseDateRegion::Europe => ReleaseDateRegion::Europe,
            ReleaseDateRegion::NorthAmerica => ReleaseDateRegion::NorthAmerica,
            ReleaseDateRegion::Australia => ReleaseDateRegion::Australia,
            ReleaseDateRegion::NewZealand => ReleaseDateRegion::NewZealand,
            ReleaseDateRegion::Japan => ReleaseDateRegion::Japan,
            ReleaseDateRegion::China => ReleaseDateRegion::China,
            ReleaseDateRegion::Asia => ReleaseDateRegion::Asia,
            ReleaseDateRegion::Korea => ReleaseDateRegion::Korea,
            ReleaseDateRegion::Brazil => ReleaseDateRegion::Brazil,
            ReleaseDateRegion::Other(v) => ReleaseDateRegion::Other(v.into_static()),
        }
    }
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ReleaseDateStatus<'a> {
    AdvancedAccess,
    Alpha,
    Beta,
    Cancelled,
    DigitalCompatibilityRelease,
    EarlyAccess,
    NextGenOptimizationRelease,
    Offline,
    Release,
    Other(CowStr<'a>),
}

impl<'a> ReleaseDateStatus<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::AdvancedAccess => "advancedAccess",
            Self::Alpha => "alpha",
            Self::Beta => "beta",
            Self::Cancelled => "cancelled",
            Self::DigitalCompatibilityRelease => "digitalCompatibilityRelease",
            Self::EarlyAccess => "earlyAccess",
            Self::NextGenOptimizationRelease => "nextGenOptimizationRelease",
            Self::Offline => "offline",
            Self::Release => "release",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for ReleaseDateStatus<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "advancedAccess" => Self::AdvancedAccess,
            "alpha" => Self::Alpha,
            "beta" => Self::Beta,
            "cancelled" => Self::Cancelled,
            "digitalCompatibilityRelease" => Self::DigitalCompatibilityRelease,
            "earlyAccess" => Self::EarlyAccess,
            "nextGenOptimizationRelease" => Self::NextGenOptimizationRelease,
            "offline" => Self::Offline,
            "release" => Self::Release,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for ReleaseDateStatus<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "advancedAccess" => Self::AdvancedAccess,
            "alpha" => Self::Alpha,
            "beta" => Self::Beta,
            "cancelled" => Self::Cancelled,
            "digitalCompatibilityRelease" => Self::DigitalCompatibilityRelease,
            "earlyAccess" => Self::EarlyAccess,
            "nextGenOptimizationRelease" => Self::NextGenOptimizationRelease,
            "offline" => Self::Offline,
            "release" => Self::Release,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for ReleaseDateStatus<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for ReleaseDateStatus<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for ReleaseDateStatus<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for ReleaseDateStatus<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for ReleaseDateStatus<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for ReleaseDateStatus<'_> {
    type Output = ReleaseDateStatus<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            ReleaseDateStatus::AdvancedAccess => ReleaseDateStatus::AdvancedAccess,
            ReleaseDateStatus::Alpha => ReleaseDateStatus::Alpha,
            ReleaseDateStatus::Beta => ReleaseDateStatus::Beta,
            ReleaseDateStatus::Cancelled => ReleaseDateStatus::Cancelled,
            ReleaseDateStatus::DigitalCompatibilityRelease => {
                ReleaseDateStatus::DigitalCompatibilityRelease
            }
            ReleaseDateStatus::EarlyAccess => ReleaseDateStatus::EarlyAccess,
            ReleaseDateStatus::NextGenOptimizationRelease => {
                ReleaseDateStatus::NextGenOptimizationRelease
            }
            ReleaseDateStatus::Offline => ReleaseDateStatus::Offline,
            ReleaseDateStatus::Release => ReleaseDateStatus::Release,
            ReleaseDateStatus::Other(v) => ReleaseDateStatus::Other(v.into_static()),
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct SkeletonGameFeedItem<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub feed_context: Option<CowStr<'a>>,
    #[serde(borrow)]
    pub game: AtUri<'a>,
}

/// System requirements for a game on a specific platform.

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct SystemRequirements<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub minimum: Option<games_gamesgamesgamesgames::SystemSpec<'a>>,
    #[serde(borrow)]
    pub platform: SystemRequirementsPlatform<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub recommended: Option<games_gamesgamesgamesgames::SystemSpec<'a>>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum SystemRequirementsPlatform<'a> {
    Windows,
    Mac,
    Linux,
    Other(CowStr<'a>),
}

impl<'a> SystemRequirementsPlatform<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Windows => "windows",
            Self::Mac => "mac",
            Self::Linux => "linux",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for SystemRequirementsPlatform<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "windows" => Self::Windows,
            "mac" => Self::Mac,
            "linux" => Self::Linux,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for SystemRequirementsPlatform<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "windows" => Self::Windows,
            "mac" => Self::Mac,
            "linux" => Self::Linux,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for SystemRequirementsPlatform<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for SystemRequirementsPlatform<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for SystemRequirementsPlatform<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for SystemRequirementsPlatform<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for SystemRequirementsPlatform<'a> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl jacquard_common::IntoStatic for SystemRequirementsPlatform<'_> {
    type Output = SystemRequirementsPlatform<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            SystemRequirementsPlatform::Windows => SystemRequirementsPlatform::Windows,
            SystemRequirementsPlatform::Mac => SystemRequirementsPlatform::Mac,
            SystemRequirementsPlatform::Linux => SystemRequirementsPlatform::Linux,
            SystemRequirementsPlatform::Other(v) => {
                SystemRequirementsPlatform::Other(v.into_static())
            }
        }
    }
}

/// Hardware/software specification for a platform.

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct SystemSpec<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub additional_notes: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub directx: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub graphics: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub memory: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub os: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub processor: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub sound_card: Option<CowStr<'a>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub storage: Option<CowStr<'a>>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Theme<'a> {
    _4x,
    Action,
    Business,
    Comedy,
    Drama,
    Educational,
    Erotic,
    Fantasy,
    Historical,
    Horror,
    Kids,
    Mystery,
    Nonfiction,
    OpenWorld,
    Party,
    Romance,
    Sandbox,
    Scifi,
    Stealth,
    Survival,
    Thriller,
    Warfare,
    Other(CowStr<'a>),
}

impl<'a> Theme<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::_4x => "4x",
            Self::Action => "action",
            Self::Business => "business",
            Self::Comedy => "comedy",
            Self::Drama => "drama",
            Self::Educational => "educational",
            Self::Erotic => "erotic",
            Self::Fantasy => "fantasy",
            Self::Historical => "historical",
            Self::Horror => "horror",
            Self::Kids => "kids",
            Self::Mystery => "mystery",
            Self::Nonfiction => "nonfiction",
            Self::OpenWorld => "openWorld",
            Self::Party => "party",
            Self::Romance => "romance",
            Self::Sandbox => "sandbox",
            Self::Scifi => "scifi",
            Self::Stealth => "stealth",
            Self::Survival => "survival",
            Self::Thriller => "thriller",
            Self::Warfare => "warfare",
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for Theme<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "4x" => Self::_4x,
            "action" => Self::Action,
            "business" => Self::Business,
            "comedy" => Self::Comedy,
            "drama" => Self::Drama,
            "educational" => Self::Educational,
            "erotic" => Self::Erotic,
            "fantasy" => Self::Fantasy,
            "historical" => Self::Historical,
            "horror" => Self::Horror,
            "kids" => Self::Kids,
            "mystery" => Self::Mystery,
            "nonfiction" => Self::Nonfiction,
            "openWorld" => Self::OpenWorld,
            "party" => Self::Party,
            "romance" => Self::Romance,
            "sandbox" => Self::Sandbox,
            "scifi" => Self::Scifi,
            "stealth" => Self::Stealth,
            "survival" => Self::Survival,
            "thriller" => Self::Thriller,
            "warfare" => Self::Warfare,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for Theme<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "4x" => Self::_4x,
            "action" => Self::Action,
            "business" => Self::Business,
            "comedy" => Self::Comedy,
            "drama" => Self::Drama,
            "educational" => Self::Educational,
            "erotic" => Self::Erotic,
            "fantasy" => Self::Fantasy,
            "historical" => Self::Historical,
            "horror" => Self::Horror,
            "kids" => Self::Kids,
            "mystery" => Self::Mystery,
            "nonfiction" => Self::Nonfiction,
            "openWorld" => Self::OpenWorld,
            "party" => Self::Party,
            "romance" => Self::Romance,
            "sandbox" => Self::Sandbox,
            "scifi" => Self::Scifi,
            "stealth" => Self::Stealth,
            "survival" => Self::Survival,
            "thriller" => Self::Thriller,
            "warfare" => Self::Warfare,
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> AsRef<str> for Theme<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> core::fmt::Display for Theme<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> serde::Serialize for Theme<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for Theme<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl jacquard_common::IntoStatic for Theme<'_> {
    type Output = Theme<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            Theme::_4x => Theme::_4x,
            Theme::Action => Theme::Action,
            Theme::Business => Theme::Business,
            Theme::Comedy => Theme::Comedy,
            Theme::Drama => Theme::Drama,
            Theme::Educational => Theme::Educational,
            Theme::Erotic => Theme::Erotic,
            Theme::Fantasy => Theme::Fantasy,
            Theme::Historical => Theme::Historical,
            Theme::Horror => Theme::Horror,
            Theme::Kids => Theme::Kids,
            Theme::Mystery => Theme::Mystery,
            Theme::Nonfiction => Theme::Nonfiction,
            Theme::OpenWorld => Theme::OpenWorld,
            Theme::Party => Theme::Party,
            Theme::Romance => Theme::Romance,
            Theme::Sandbox => Theme::Sandbox,
            Theme::Scifi => Theme::Scifi,
            Theme::Stealth => Theme::Stealth,
            Theme::Survival => Theme::Survival,
            Theme::Thriller => Theme::Thriller,
            Theme::Warfare => Theme::Warfare,
            Theme::Other(v) => Theme::Other(v.into_static()),
        }
    }
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct TimeToBeat<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completely: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hastily: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub normally: Option<i64>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase")]
pub struct ViewerState<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub like: Option<AtUri<'a>>,
}


#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct Website<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub r#type: Option<WebsiteType<'a>>,
    #[serde(borrow)]
    pub url: UriValue<'a>,
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum WebsiteType<'a> {
    Official,
    Wiki,
    Steam,
    Gog,
    EpicGames,
    ItchIo,
    Twitter,
    Instagram,
    Youtube,
    Twitch,
    Discord,
    Reddit,
    Facebook,
    Wikipedia,
    Bluesky,
    Xbox,
    Playstation,
    Nintendo,
    Meta,
    Other,
    UnknownValue(CowStr<'a>),
}

impl<'a> WebsiteType<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Official => "official",
            Self::Wiki => "wiki",
            Self::Steam => "steam",
            Self::Gog => "gog",
            Self::EpicGames => "epicGames",
            Self::ItchIo => "itchIo",
            Self::Twitter => "twitter",
            Self::Instagram => "instagram",
            Self::Youtube => "youtube",
            Self::Twitch => "twitch",
            Self::Discord => "discord",
            Self::Reddit => "reddit",
            Self::Facebook => "facebook",
            Self::Wikipedia => "wikipedia",
            Self::Bluesky => "bluesky",
            Self::Xbox => "xbox",
            Self::Playstation => "playstation",
            Self::Nintendo => "nintendo",
            Self::Meta => "meta",
            Self::Other => "other",
            Self::UnknownValue(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for WebsiteType<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "official" => Self::Official,
            "wiki" => Self::Wiki,
            "steam" => Self::Steam,
            "gog" => Self::Gog,
            "epicGames" => Self::EpicGames,
            "itchIo" => Self::ItchIo,
            "twitter" => Self::Twitter,
            "instagram" => Self::Instagram,
            "youtube" => Self::Youtube,
            "twitch" => Self::Twitch,
            "discord" => Self::Discord,
            "reddit" => Self::Reddit,
            "facebook" => Self::Facebook,
            "wikipedia" => Self::Wikipedia,
            "bluesky" => Self::Bluesky,
            "xbox" => Self::Xbox,
            "playstation" => Self::Playstation,
            "nintendo" => Self::Nintendo,
            "meta" => Self::Meta,
            "other" => Self::Other,
            _ => Self::UnknownValue(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for WebsiteType<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "official" => Self::Official,
            "wiki" => Self::Wiki,
            "steam" => Self::Steam,
            "gog" => Self::Gog,
            "epicGames" => Self::EpicGames,
            "itchIo" => Self::ItchIo,
            "twitter" => Self::Twitter,
            "instagram" => Self::Instagram,
            "youtube" => Self::Youtube,
            "twitch" => Self::Twitch,
            "discord" => Self::Discord,
            "reddit" => Self::Reddit,
            "facebook" => Self::Facebook,
            "wikipedia" => Self::Wikipedia,
            "bluesky" => Self::Bluesky,
            "xbox" => Self::Xbox,
            "playstation" => Self::Playstation,
            "nintendo" => Self::Nintendo,
            "meta" => Self::Meta,
            "other" => Self::Other,
            _ => Self::UnknownValue(CowStr::from(s)),
        }
    }
}

impl<'a> core::fmt::Display for WebsiteType<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> AsRef<str> for WebsiteType<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> serde::Serialize for WebsiteType<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for WebsiteType<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl<'a> Default for WebsiteType<'a> {
    fn default() -> Self {
        Self::UnknownValue(Default::default())
    }
}

impl jacquard_common::IntoStatic for WebsiteType<'_> {
    type Output = WebsiteType<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            WebsiteType::Official => WebsiteType::Official,
            WebsiteType::Wiki => WebsiteType::Wiki,
            WebsiteType::Steam => WebsiteType::Steam,
            WebsiteType::Gog => WebsiteType::Gog,
            WebsiteType::EpicGames => WebsiteType::EpicGames,
            WebsiteType::ItchIo => WebsiteType::ItchIo,
            WebsiteType::Twitter => WebsiteType::Twitter,
            WebsiteType::Instagram => WebsiteType::Instagram,
            WebsiteType::Youtube => WebsiteType::Youtube,
            WebsiteType::Twitch => WebsiteType::Twitch,
            WebsiteType::Discord => WebsiteType::Discord,
            WebsiteType::Reddit => WebsiteType::Reddit,
            WebsiteType::Facebook => WebsiteType::Facebook,
            WebsiteType::Wikipedia => WebsiteType::Wikipedia,
            WebsiteType::Bluesky => WebsiteType::Bluesky,
            WebsiteType::Xbox => WebsiteType::Xbox,
            WebsiteType::Playstation => WebsiteType::Playstation,
            WebsiteType::Nintendo => WebsiteType::Nintendo,
            WebsiteType::Meta => WebsiteType::Meta,
            WebsiteType::Other => WebsiteType::Other,
            WebsiteType::UnknownValue(v) => WebsiteType::UnknownValue(v.into_static()),
        }
    }
}

impl<'a> LexiconSchema for ActorCreditView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "actorCreditView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.display_name {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 640usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("display_name"),
                    max: 640usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for ActorProfileDetailView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "actorProfileDetailView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.avatar {
            {
                let size = value.blob().size;
                if size > 10000000usize {
                    return Err(ConstraintError::BlobTooLarge {
                        path: ValidationPath::from_field("avatar"),
                        max: 10000000usize,
                        actual: size,
                    });
                }
            }
        }
        if let Some(ref value) = self.avatar {
            {
                let mime = value.blob().mime_type.as_str();
                let accepted: &[&str] = &["image/png", "image/jpeg"];
                let matched = accepted
                    .iter()
                    .any(|pattern| {
                        if *pattern == "*/*" {
                            true
                        } else if pattern.ends_with("/*") {
                            let prefix = &pattern[..pattern.len() - 2];
                            mime.starts_with(prefix)
                                && mime.as_bytes().get(prefix.len()) == Some(&b'/')
                        } else {
                            mime == *pattern
                        }
                    });
                if !matched {
                    return Err(ConstraintError::BlobMimeTypeNotAccepted {
                        path: ValidationPath::from_field("avatar"),
                        accepted: vec![
                            "image/png".to_string(), "image/jpeg".to_string()
                        ],
                        actual: mime.to_string(),
                    });
                }
            }
        }
        if let Some(ref value) = self.description {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 3000usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("description"),
                    max: 3000usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        if let Some(ref value) = self.display_name {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 640usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("display_name"),
                    max: 640usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        if let Some(ref value) = self.pronouns {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 200usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("pronouns"),
                    max: 200usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for ActorProfileSummaryView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "actorProfileSummaryView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.avatar {
            {
                let size = value.blob().size;
                if size > 10000000usize {
                    return Err(ConstraintError::BlobTooLarge {
                        path: ValidationPath::from_field("avatar"),
                        max: 10000000usize,
                        actual: size,
                    });
                }
            }
        }
        if let Some(ref value) = self.avatar {
            {
                let mime = value.blob().mime_type.as_str();
                let accepted: &[&str] = &["image/png", "image/jpeg"];
                let matched = accepted
                    .iter()
                    .any(|pattern| {
                        if *pattern == "*/*" {
                            true
                        } else if pattern.ends_with("/*") {
                            let prefix = &pattern[..pattern.len() - 2];
                            mime.starts_with(prefix)
                                && mime.as_bytes().get(prefix.len()) == Some(&b'/')
                        } else {
                            mime == *pattern
                        }
                    });
                if !matched {
                    return Err(ConstraintError::BlobMimeTypeNotAccepted {
                        path: ValidationPath::from_field("avatar"),
                        accepted: vec![
                            "image/png".to_string(), "image/jpeg".to_string()
                        ],
                        actual: mime.to_string(),
                    });
                }
            }
        }
        if let Some(ref value) = self.display_name {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 640usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("display_name"),
                    max: 640usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for AgeRating<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "ageRating"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for AlternativeName<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "alternativeName"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for CollectionSummaryView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "collectionSummaryView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for CreditEntry<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "creditEntry"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.department {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 640usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("department"),
                    max: 640usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for EngineSummaryView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "engineSummaryView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for ExternalIds<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "externalIds"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for ExternalVideo<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "externalVideo"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for GameDetailView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "gameDetailView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for GameFeedViewItem<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "gameFeedViewItem"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.feed_context {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 2000usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("feed_context"),
                    max: 2000usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for GameSummaryView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "gameSummaryView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for GameView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "gameView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.like_count {
            if *value < 0i64 {
                return Err(ConstraintError::Minimum {
                    path: ValidationPath::from_field("like_count"),
                    min: 0i64,
                    actual: *value,
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for ItchIoId<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "itchIoId"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for LanguageSupport<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "languageSupport"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for MediaItem<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "mediaItem"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.blob {
            {
                let size = value.blob().size;
                if size > 200000000usize {
                    return Err(ConstraintError::BlobTooLarge {
                        path: ValidationPath::from_field("blob"),
                        max: 200000000usize,
                        actual: size,
                    });
                }
            }
        }
        if let Some(ref value) = self.blob {
            {
                let mime = value.blob().mime_type.as_str();
                let accepted: &[&str] = &["image/*", "video/*"];
                let matched = accepted
                    .iter()
                    .any(|pattern| {
                        if *pattern == "*/*" {
                            true
                        } else if pattern.ends_with("/*") {
                            let prefix = &pattern[..pattern.len() - 2];
                            mime.starts_with(prefix)
                                && mime.as_bytes().get(prefix.len()) == Some(&b'/')
                        } else {
                            mime == *pattern
                        }
                    });
                if !matched {
                    return Err(ConstraintError::BlobMimeTypeNotAccepted {
                        path: ValidationPath::from_field("blob"),
                        accepted: vec!["image/*".to_string(), "video/*".to_string()],
                        actual: mime.to_string(),
                    });
                }
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for MultiplayerMode<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "multiplayerMode"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for OrgCreditView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "orgCreditView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.display_name {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 640usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("display_name"),
                    max: 640usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for OrgProfileDetailView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "orgProfileDetailView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.avatar {
            {
                let size = value.blob().size;
                if size > 10000000usize {
                    return Err(ConstraintError::BlobTooLarge {
                        path: ValidationPath::from_field("avatar"),
                        max: 10000000usize,
                        actual: size,
                    });
                }
            }
        }
        if let Some(ref value) = self.avatar {
            {
                let mime = value.blob().mime_type.as_str();
                let accepted: &[&str] = &["image/png", "image/jpeg"];
                let matched = accepted
                    .iter()
                    .any(|pattern| {
                        if *pattern == "*/*" {
                            true
                        } else if pattern.ends_with("/*") {
                            let prefix = &pattern[..pattern.len() - 2];
                            mime.starts_with(prefix)
                                && mime.as_bytes().get(prefix.len()) == Some(&b'/')
                        } else {
                            mime == *pattern
                        }
                    });
                if !matched {
                    return Err(ConstraintError::BlobMimeTypeNotAccepted {
                        path: ValidationPath::from_field("avatar"),
                        accepted: vec![
                            "image/png".to_string(), "image/jpeg".to_string()
                        ],
                        actual: mime.to_string(),
                    });
                }
            }
        }
        if let Some(ref value) = self.description {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 3000usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("description"),
                    max: 3000usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        if let Some(ref value) = self.display_name {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 640usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("display_name"),
                    max: 640usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for OrgProfileSummaryView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "orgProfileSummaryView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.avatar {
            {
                let size = value.blob().size;
                if size > 10000000usize {
                    return Err(ConstraintError::BlobTooLarge {
                        path: ValidationPath::from_field("avatar"),
                        max: 10000000usize,
                        actual: size,
                    });
                }
            }
        }
        if let Some(ref value) = self.avatar {
            {
                let mime = value.blob().mime_type.as_str();
                let accepted: &[&str] = &["image/png", "image/jpeg"];
                let matched = accepted
                    .iter()
                    .any(|pattern| {
                        if *pattern == "*/*" {
                            true
                        } else if pattern.ends_with("/*") {
                            let prefix = &pattern[..pattern.len() - 2];
                            mime.starts_with(prefix)
                                && mime.as_bytes().get(prefix.len()) == Some(&b'/')
                        } else {
                            mime == *pattern
                        }
                    });
                if !matched {
                    return Err(ConstraintError::BlobMimeTypeNotAccepted {
                        path: ValidationPath::from_field("avatar"),
                        accepted: vec![
                            "image/png".to_string(), "image/jpeg".to_string()
                        ],
                        actual: mime.to_string(),
                    });
                }
            }
        }
        if let Some(ref value) = self.display_name {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 640usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("display_name"),
                    max: 640usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for PlatformFeatures<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "platformFeatures"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for PlatformSummaryView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "platformSummaryView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for PlatformVersion<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "platformVersion"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for ProfileSummaryView<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "profileSummaryView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.avatar {
            {
                let size = value.blob().size;
                if size > 10000000usize {
                    return Err(ConstraintError::BlobTooLarge {
                        path: ValidationPath::from_field("avatar"),
                        max: 10000000usize,
                        actual: size,
                    });
                }
            }
        }
        if let Some(ref value) = self.avatar {
            {
                let mime = value.blob().mime_type.as_str();
                let accepted: &[&str] = &["image/png", "image/jpeg"];
                let matched = accepted
                    .iter()
                    .any(|pattern| {
                        if *pattern == "*/*" {
                            true
                        } else if pattern.ends_with("/*") {
                            let prefix = &pattern[..pattern.len() - 2];
                            mime.starts_with(prefix)
                                && mime.as_bytes().get(prefix.len()) == Some(&b'/')
                        } else {
                            mime == *pattern
                        }
                    });
                if !matched {
                    return Err(ConstraintError::BlobMimeTypeNotAccepted {
                        path: ValidationPath::from_field("avatar"),
                        accepted: vec![
                            "image/png".to_string(), "image/jpeg".to_string()
                        ],
                        actual: mime.to_string(),
                    });
                }
            }
        }
        if let Some(ref value) = self.display_name {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 640usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("display_name"),
                    max: 640usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for Release<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "release"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for ReleaseDate<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "releaseDate"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for SkeletonGameFeedItem<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "skeletonGameFeedItem"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.feed_context {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 2000usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("feed_context"),
                    max: 2000usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        Ok(())
    }
}

impl<'a> LexiconSchema for SystemRequirements<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "systemRequirements"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for SystemSpec<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "systemSpec"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for TimeToBeat<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "timeToBeat"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for ViewerState<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "viewerState"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<'a> LexiconSchema for Website<'a> {
    fn nsid() -> &'static str {
        "games.gamesgamesgamesgames.defs"
    }
    fn def_name() -> &'static str {
        "website"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_games_gamesgamesgamesgames_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

pub mod actor_credit_view_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 {
        type Credits;
        type Uri;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Credits = Unset;
        type Uri = Unset;
    }
    ///State transition - sets the `credits` field to Set
    pub struct SetCredits<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetCredits<S> {}
    impl<S: State> State for SetCredits<S> {
        type Credits = Set<members::credits>;
        type Uri = S::Uri;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Credits = S::Credits;
        type Uri = Set<members::uri>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `credits` field
        pub struct credits(());
        ///Marker type for the `uri` field
        pub struct uri(());
    }
}

/// Builder for constructing an instance of this type
pub struct ActorCreditViewBuilder<'a, S: actor_credit_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<AtUri<'a>>,
        Option<Vec<games_gamesgamesgamesgames::CreditEntry<'a>>>,
        Option<CowStr<'a>>,
        Option<AtUri<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> ActorCreditView<'a> {
    /// Create a new builder for this type
    pub fn new() -> ActorCreditViewBuilder<'a, actor_credit_view_state::Empty> {
        ActorCreditViewBuilder::new()
    }
}

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

impl<'a, S: actor_credit_view_state::State> ActorCreditViewBuilder<'a, S> {
    /// Set the `actorUri` field (optional)
    pub fn actor_uri(mut self, value: impl Into<Option<AtUri<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `actorUri` field to an Option value (optional)
    pub fn maybe_actor_uri(mut self, value: Option<AtUri<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S> ActorCreditViewBuilder<'a, S>
where
    S: actor_credit_view_state::State,
    S::Credits: actor_credit_view_state::IsUnset,
{
    /// Set the `credits` field (required)
    pub fn credits(
        mut self,
        value: impl Into<Vec<games_gamesgamesgamesgames::CreditEntry<'a>>>,
    ) -> ActorCreditViewBuilder<'a, actor_credit_view_state::SetCredits<S>> {
        self._fields.1 = Option::Some(value.into());
        ActorCreditViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: actor_credit_view_state::State> ActorCreditViewBuilder<'a, S> {
    /// Set the `displayName` field (optional)
    pub fn display_name(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `displayName` field to an Option value (optional)
    pub fn maybe_display_name(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S> ActorCreditViewBuilder<'a, S>
where
    S: actor_credit_view_state::State,
    S::Uri: actor_credit_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> ActorCreditViewBuilder<'a, actor_credit_view_state::SetUri<S>> {
        self._fields.3 = Option::Some(value.into());
        ActorCreditViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> ActorCreditViewBuilder<'a, S>
where
    S: actor_credit_view_state::State,
    S::Credits: actor_credit_view_state::IsSet,
    S::Uri: actor_credit_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> ActorCreditView<'a> {
        ActorCreditView {
            actor_uri: self._fields.0,
            credits: self._fields.1.unwrap(),
            display_name: self._fields.2,
            uri: self._fields.3.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> ActorCreditView<'a> {
        ActorCreditView {
            actor_uri: self._fields.0,
            credits: self._fields.1.unwrap(),
            display_name: self._fields.2,
            uri: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

fn lexicon_doc_games_gamesgamesgamesgames_defs() -> 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("games.gamesgamesgamesgames.defs"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("actorCreditView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("credits")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("actorUri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("credits"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#creditEntry",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("displayName"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(640usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("actorProfileDetailView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("did")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("avatar"),
                            LexObjectProperty::Blob(LexBlob { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("createdAt"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Datetime),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("description"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(3000usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("descriptionFacets"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static("app.bsky.richtext.facet"),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("did"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Did),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("displayName"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(640usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("pronouns"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(200usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("websites"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#website",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("actorProfileSummaryView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("did")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("avatar"),
                            LexObjectProperty::Blob(LexBlob { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("did"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Did),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("displayName"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(640usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("ageRating"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("organization"),
                            SmolStr::new_static("rating")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("contentDescriptors"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::String(LexString {
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("organization"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("rating"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("alternativeName"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("name")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("comment"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("locale"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("applicationType"),
                LexUserType::String(LexString { ..Default::default() }),
            );
            map.insert(
                SmolStr::new_static("collectionSummaryView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("name")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("slug"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("type"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("companyRole"),
                LexUserType::String(LexString { ..Default::default() }),
            );
            map.insert(
                SmolStr::new_static("creditEntry"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("role")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("department"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(640usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("role"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#individualRole",
                                ),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("engineSummaryView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("name")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("slug"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("externalIds"),
                LexUserType::Object(LexObject {
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("appleAppStore"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("epicGames"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("gog"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("googlePlay"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("humbleBundle"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("igdb"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("itchIo"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#itchIoId",
                                ),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("nintendoEshop"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("playStation"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("steam"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("twitch"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("xbox"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("externalVideo"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("videoId"),
                            SmolStr::new_static("platform")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("platform"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("title"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("videoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("gameDetailView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("name"), SmolStr::new_static("uri"),
                            SmolStr::new_static("createdAt")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("actorCredits"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#actorCreditView",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("ageRatings"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#ageRating",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("alternativeNames"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#alternativeName",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("applicationType"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#applicationType",
                                ),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("collections"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::String(LexString {
                                    format: Some(LexStringFormat::AtUri),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("createdAt"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Datetime),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("engines"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::String(LexString {
                                    format: Some(LexStringFormat::AtUri),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("externalIds"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#externalIds",
                                ),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("genres"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#genre",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("keywords"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::String(LexString {
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("languageSupports"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#languageSupport",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("media"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#mediaItem",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("modes"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#mode",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("multiplayerModes"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#multiplayerMode",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("orgCredits"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#orgCreditView",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("parent"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("playerPerspectives"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#playerPerspective",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("publishedAt"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Datetime),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("releases"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#release",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("slug"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("storyline"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("summary"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("themes"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#theme",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("timeToBeat"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#timeToBeat",
                                ),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("videos"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#externalVideo",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("websites"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#website",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("gameFeedViewItem"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("game")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("feedContext"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(2000usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("game"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#gameView",
                                ),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("gameSummaryView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("name")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("applicationType"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#applicationType",
                                ),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("firstReleaseDate"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("media"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#mediaItem",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("slug"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("summary"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("gameView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("uri"), SmolStr::new_static("name"),
                            SmolStr::new_static("applicationType")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("applicationType"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#applicationType",
                                ),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("genres"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#genre",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("likeCount"),
                            LexObjectProperty::Integer(LexInteger {
                                minimum: Some(0i64),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("media"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#mediaItem",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("releases"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#release",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("slug"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("summary"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("themes"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#theme",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("viewer"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#viewerState",
                                ),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("genre"),
                LexUserType::String(LexString { ..Default::default() }),
            );
            map.insert(
                SmolStr::new_static("individualRole"),
                LexUserType::String(LexString { ..Default::default() }),
            );
            map.insert(
                SmolStr::new_static("itchIoId"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("developer"), SmolStr::new_static("game")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("developer"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("game"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("languageSupport"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("language")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("audio"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("interface"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("language"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("subtitles"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("mediaItem"),
                LexUserType::Object(LexObject {
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("blob"),
                            LexObjectProperty::Blob(LexBlob { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("description"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("height"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("locale"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("mediaType"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("title"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("width"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("mode"),
                LexUserType::String(LexString { ..Default::default() }),
            );
            map.insert(
                SmolStr::new_static("multiplayerMode"),
                LexUserType::Object(LexObject {
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("hasCampaignCoop"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasDropIn"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasLanCoop"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasSplitscreen"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hasSplitscreenOnline"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("offlineCoopMax"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("offlineMax"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("onlineCoopMax"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("onlineMax"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("platform"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("orgCreditView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("roles")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("displayName"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(640usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("orgUri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("roles"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#companyRole",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("orgProfileDetailView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("did")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("avatar"),
                            LexObjectProperty::Blob(LexBlob { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("country"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("createdAt"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Datetime),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("description"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(3000usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("descriptionFacets"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static("app.bsky.richtext.facet"),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("did"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Did),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("displayName"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(640usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("foundedAt"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Datetime),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("media"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#mediaItem",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("parent"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("status"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("websites"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#website",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("orgProfileSummaryView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("did")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("avatar"),
                            LexObjectProperty::Blob(LexBlob { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("did"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Did),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("displayName"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(640usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("platformCategory"),
                LexUserType::String(LexString { ..Default::default() }),
            );
            map.insert(
                SmolStr::new_static("platformFeatures"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "Features supported by a game on a specific storefront/platform.",
                        ),
                    ),
                    required: Some(
                        vec![
                            SmolStr::new_static("platform"),
                            SmolStr::new_static("features")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("features"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::String(LexString {
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("platform"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("platformSummaryView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("uri"), SmolStr::new_static("name")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("abbreviation"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("category"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static(
                                    "games.gamesgamesgamesgames.defs#platformCategory",
                                ),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("slug"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("platformVersion"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("name")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("connectivity"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("cpu"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("gpu"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("maxResolution"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("media"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#mediaItem",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("memory"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("name"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("os"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("output"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("storage"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("summary"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("playerPerspective"),
                LexUserType::String(LexString { ..Default::default() }),
            );
            map.insert(
                SmolStr::new_static("profileSummaryView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("uri"), SmolStr::new_static("did"),
                            SmolStr::new_static("profileType")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("avatar"),
                            LexObjectProperty::Blob(LexBlob { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("did"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Did),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("displayName"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(640usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("profileType"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("uri"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("release"),
                LexUserType::Object(LexObject {
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("platform"),
                            LexObjectProperty::String(LexString {
                                description: Some(
                                    CowStr::new_static(
                                        "Free-text platform name, used when no platform record exists.",
                                    ),
                                ),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("platformUri"),
                            LexObjectProperty::String(LexString {
                                description: Some(
                                    CowStr::new_static("AT URI of a platform record."),
                                ),
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("releaseDates"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "games.gamesgamesgamesgames.defs#releaseDate",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("releaseDate"),
                LexUserType::Object(LexObject {
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("region"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("releasedAt"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("releasedAtFormat"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("status"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("skeletonGameFeedItem"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("game")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("feedContext"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(2000usize),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("game"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("systemRequirements"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "System requirements for a game on a specific platform.",
                        ),
                    ),
                    required: Some(vec![SmolStr::new_static("platform")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("minimum"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#systemSpec"),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("platform"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("recommended"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#systemSpec"),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("systemSpec"),
                LexUserType::Object(LexObject {
                    description: Some(
                        CowStr::new_static(
                            "Hardware/software specification for a platform.",
                        ),
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("additionalNotes"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("directx"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("graphics"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("memory"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("os"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("processor"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("soundCard"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("storage"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("theme"),
                LexUserType::String(LexString { ..Default::default() }),
            );
            map.insert(
                SmolStr::new_static("timeToBeat"),
                LexUserType::Object(LexObject {
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("completely"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("hastily"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("normally"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("viewerState"),
                LexUserType::Object(LexObject {
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("like"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::AtUri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("website"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("url")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("type"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("url"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Uri),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}

pub mod actor_profile_detail_view_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 {
        type Uri;
        type Did;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Uri = Unset;
        type Did = Unset;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Uri = Set<members::uri>;
        type Did = S::Did;
    }
    ///State transition - sets the `did` field to Set
    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetDid<S> {}
    impl<S: State> State for SetDid<S> {
        type Uri = S::Uri;
        type Did = Set<members::did>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `uri` field
        pub struct uri(());
        ///Marker type for the `did` field
        pub struct did(());
    }
}

/// Builder for constructing an instance of this type
pub struct ActorProfileDetailViewBuilder<'a, S: actor_profile_detail_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<BlobRef<'a>>,
        Option<Datetime>,
        Option<CowStr<'a>>,
        Option<Vec<Facet<'a>>>,
        Option<Did<'a>>,
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<AtUri<'a>>,
        Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> ActorProfileDetailView<'a> {
    /// Create a new builder for this type
    pub fn new() -> ActorProfileDetailViewBuilder<
        'a,
        actor_profile_detail_view_state::Empty,
    > {
        ActorProfileDetailViewBuilder::new()
    }
}

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

impl<
    'a,
    S: actor_profile_detail_view_state::State,
> ActorProfileDetailViewBuilder<'a, S> {
    /// Set the `avatar` field (optional)
    pub fn avatar(mut self, value: impl Into<Option<BlobRef<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `avatar` field to an Option value (optional)
    pub fn maybe_avatar(mut self, value: Option<BlobRef<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<
    'a,
    S: actor_profile_detail_view_state::State,
> ActorProfileDetailViewBuilder<'a, S> {
    /// Set the `createdAt` field (optional)
    pub fn created_at(mut self, value: impl Into<Option<Datetime>>) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `createdAt` field to an Option value (optional)
    pub fn maybe_created_at(mut self, value: Option<Datetime>) -> Self {
        self._fields.1 = value;
        self
    }
}

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

impl<
    'a,
    S: actor_profile_detail_view_state::State,
> ActorProfileDetailViewBuilder<'a, S> {
    /// Set the `descriptionFacets` field (optional)
    pub fn description_facets(
        mut self,
        value: impl Into<Option<Vec<Facet<'a>>>>,
    ) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `descriptionFacets` field to an Option value (optional)
    pub fn maybe_description_facets(mut self, value: Option<Vec<Facet<'a>>>) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<'a, S> ActorProfileDetailViewBuilder<'a, S>
where
    S: actor_profile_detail_view_state::State,
    S::Did: actor_profile_detail_view_state::IsUnset,
{
    /// Set the `did` field (required)
    pub fn did(
        mut self,
        value: impl Into<Did<'a>>,
    ) -> ActorProfileDetailViewBuilder<'a, actor_profile_detail_view_state::SetDid<S>> {
        self._fields.4 = Option::Some(value.into());
        ActorProfileDetailViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<
    'a,
    S: actor_profile_detail_view_state::State,
> ActorProfileDetailViewBuilder<'a, S> {
    /// Set the `displayName` field (optional)
    pub fn display_name(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.5 = value.into();
        self
    }
    /// Set the `displayName` field to an Option value (optional)
    pub fn maybe_display_name(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.5 = value;
        self
    }
}

impl<
    'a,
    S: actor_profile_detail_view_state::State,
> ActorProfileDetailViewBuilder<'a, S> {
    /// Set the `pronouns` field (optional)
    pub fn pronouns(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `pronouns` field to an Option value (optional)
    pub fn maybe_pronouns(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<'a, S> ActorProfileDetailViewBuilder<'a, S>
where
    S: actor_profile_detail_view_state::State,
    S::Uri: actor_profile_detail_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> ActorProfileDetailViewBuilder<'a, actor_profile_detail_view_state::SetUri<S>> {
        self._fields.7 = Option::Some(value.into());
        ActorProfileDetailViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<
    'a,
    S: actor_profile_detail_view_state::State,
> ActorProfileDetailViewBuilder<'a, S> {
    /// Set the `websites` field (optional)
    pub fn websites(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Website<'a>>>>,
    ) -> Self {
        self._fields.8 = value.into();
        self
    }
    /// Set the `websites` field to an Option value (optional)
    pub fn maybe_websites(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
    ) -> Self {
        self._fields.8 = value;
        self
    }
}

impl<'a, S> ActorProfileDetailViewBuilder<'a, S>
where
    S: actor_profile_detail_view_state::State,
    S::Uri: actor_profile_detail_view_state::IsSet,
    S::Did: actor_profile_detail_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> ActorProfileDetailView<'a> {
        ActorProfileDetailView {
            avatar: self._fields.0,
            created_at: self._fields.1,
            description: self._fields.2,
            description_facets: self._fields.3,
            did: self._fields.4.unwrap(),
            display_name: self._fields.5,
            pronouns: self._fields.6,
            uri: self._fields.7.unwrap(),
            websites: self._fields.8,
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> ActorProfileDetailView<'a> {
        ActorProfileDetailView {
            avatar: self._fields.0,
            created_at: self._fields.1,
            description: self._fields.2,
            description_facets: self._fields.3,
            did: self._fields.4.unwrap(),
            display_name: self._fields.5,
            pronouns: self._fields.6,
            uri: self._fields.7.unwrap(),
            websites: self._fields.8,
            extra_data: Some(extra_data),
        }
    }
}

pub mod actor_profile_summary_view_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 {
        type Uri;
        type Did;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Uri = Unset;
        type Did = Unset;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Uri = Set<members::uri>;
        type Did = S::Did;
    }
    ///State transition - sets the `did` field to Set
    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetDid<S> {}
    impl<S: State> State for SetDid<S> {
        type Uri = S::Uri;
        type Did = Set<members::did>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `uri` field
        pub struct uri(());
        ///Marker type for the `did` field
        pub struct did(());
    }
}

/// Builder for constructing an instance of this type
pub struct ActorProfileSummaryViewBuilder<
    'a,
    S: actor_profile_summary_view_state::State,
> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<BlobRef<'a>>,
        Option<Did<'a>>,
        Option<CowStr<'a>>,
        Option<AtUri<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> ActorProfileSummaryView<'a> {
    /// Create a new builder for this type
    pub fn new() -> ActorProfileSummaryViewBuilder<
        'a,
        actor_profile_summary_view_state::Empty,
    > {
        ActorProfileSummaryViewBuilder::new()
    }
}

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

impl<
    'a,
    S: actor_profile_summary_view_state::State,
> ActorProfileSummaryViewBuilder<'a, S> {
    /// Set the `avatar` field (optional)
    pub fn avatar(mut self, value: impl Into<Option<BlobRef<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `avatar` field to an Option value (optional)
    pub fn maybe_avatar(mut self, value: Option<BlobRef<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S> ActorProfileSummaryViewBuilder<'a, S>
where
    S: actor_profile_summary_view_state::State,
    S::Did: actor_profile_summary_view_state::IsUnset,
{
    /// Set the `did` field (required)
    pub fn did(
        mut self,
        value: impl Into<Did<'a>>,
    ) -> ActorProfileSummaryViewBuilder<
        'a,
        actor_profile_summary_view_state::SetDid<S>,
    > {
        self._fields.1 = Option::Some(value.into());
        ActorProfileSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<
    'a,
    S: actor_profile_summary_view_state::State,
> ActorProfileSummaryViewBuilder<'a, S> {
    /// Set the `displayName` field (optional)
    pub fn display_name(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `displayName` field to an Option value (optional)
    pub fn maybe_display_name(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S> ActorProfileSummaryViewBuilder<'a, S>
where
    S: actor_profile_summary_view_state::State,
    S::Uri: actor_profile_summary_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> ActorProfileSummaryViewBuilder<
        'a,
        actor_profile_summary_view_state::SetUri<S>,
    > {
        self._fields.3 = Option::Some(value.into());
        ActorProfileSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> ActorProfileSummaryViewBuilder<'a, S>
where
    S: actor_profile_summary_view_state::State,
    S::Uri: actor_profile_summary_view_state::IsSet,
    S::Did: actor_profile_summary_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> ActorProfileSummaryView<'a> {
        ActorProfileSummaryView {
            avatar: self._fields.0,
            did: self._fields.1.unwrap(),
            display_name: self._fields.2,
            uri: self._fields.3.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> ActorProfileSummaryView<'a> {
        ActorProfileSummaryView {
            avatar: self._fields.0,
            did: self._fields.1.unwrap(),
            display_name: self._fields.2,
            uri: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod collection_summary_view_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 {
        type Uri;
        type Name;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Uri = Unset;
        type Name = Unset;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Uri = Set<members::uri>;
        type Name = S::Name;
    }
    ///State transition - sets the `name` field to Set
    pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetName<S> {}
    impl<S: State> State for SetName<S> {
        type Uri = S::Uri;
        type Name = Set<members::name>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `uri` field
        pub struct uri(());
        ///Marker type for the `name` field
        pub struct name(());
    }
}

/// Builder for constructing an instance of this type
pub struct CollectionSummaryViewBuilder<'a, S: collection_summary_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<CollectionSummaryViewType<'a>>,
        Option<AtUri<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> CollectionSummaryView<'a> {
    /// Create a new builder for this type
    pub fn new() -> CollectionSummaryViewBuilder<
        'a,
        collection_summary_view_state::Empty,
    > {
        CollectionSummaryViewBuilder::new()
    }
}

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

impl<'a, S> CollectionSummaryViewBuilder<'a, S>
where
    S: collection_summary_view_state::State,
    S::Name: collection_summary_view_state::IsUnset,
{
    /// Set the `name` field (required)
    pub fn name(
        mut self,
        value: impl Into<CowStr<'a>>,
    ) -> CollectionSummaryViewBuilder<'a, collection_summary_view_state::SetName<S>> {
        self._fields.0 = Option::Some(value.into());
        CollectionSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: collection_summary_view_state::State> CollectionSummaryViewBuilder<'a, S> {
    /// Set the `slug` field (optional)
    pub fn slug(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `slug` field to an Option value (optional)
    pub fn maybe_slug(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S: collection_summary_view_state::State> CollectionSummaryViewBuilder<'a, S> {
    /// Set the `type` field (optional)
    pub fn r#type(
        mut self,
        value: impl Into<Option<CollectionSummaryViewType<'a>>>,
    ) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `type` field to an Option value (optional)
    pub fn maybe_type(mut self, value: Option<CollectionSummaryViewType<'a>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S> CollectionSummaryViewBuilder<'a, S>
where
    S: collection_summary_view_state::State,
    S::Uri: collection_summary_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> CollectionSummaryViewBuilder<'a, collection_summary_view_state::SetUri<S>> {
        self._fields.3 = Option::Some(value.into());
        CollectionSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> CollectionSummaryViewBuilder<'a, S>
where
    S: collection_summary_view_state::State,
    S::Uri: collection_summary_view_state::IsSet,
    S::Name: collection_summary_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> CollectionSummaryView<'a> {
        CollectionSummaryView {
            name: self._fields.0.unwrap(),
            slug: self._fields.1,
            r#type: self._fields.2,
            uri: self._fields.3.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> CollectionSummaryView<'a> {
        CollectionSummaryView {
            name: self._fields.0.unwrap(),
            slug: self._fields.1,
            r#type: self._fields.2,
            uri: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod credit_entry_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 {
        type Role;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Role = Unset;
    }
    ///State transition - sets the `role` field to Set
    pub struct SetRole<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetRole<S> {}
    impl<S: State> State for SetRole<S> {
        type Role = Set<members::role>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `role` field
        pub struct role(());
    }
}

/// Builder for constructing an instance of this type
pub struct CreditEntryBuilder<'a, S: credit_entry_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<CowStr<'a>>,
        Option<games_gamesgamesgamesgames::IndividualRole<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> CreditEntry<'a> {
    /// Create a new builder for this type
    pub fn new() -> CreditEntryBuilder<'a, credit_entry_state::Empty> {
        CreditEntryBuilder::new()
    }
}

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

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

impl<'a, S> CreditEntryBuilder<'a, S>
where
    S: credit_entry_state::State,
    S::Role: credit_entry_state::IsUnset,
{
    /// Set the `role` field (required)
    pub fn role(
        mut self,
        value: impl Into<games_gamesgamesgamesgames::IndividualRole<'a>>,
    ) -> CreditEntryBuilder<'a, credit_entry_state::SetRole<S>> {
        self._fields.1 = Option::Some(value.into());
        CreditEntryBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> CreditEntryBuilder<'a, S>
where
    S: credit_entry_state::State,
    S::Role: credit_entry_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> CreditEntry<'a> {
        CreditEntry {
            department: self._fields.0,
            role: self._fields.1.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> CreditEntry<'a> {
        CreditEntry {
            department: self._fields.0,
            role: self._fields.1.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod engine_summary_view_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 {
        type Name;
        type Uri;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Name = Unset;
        type Uri = Unset;
    }
    ///State transition - sets the `name` field to Set
    pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetName<S> {}
    impl<S: State> State for SetName<S> {
        type Name = Set<members::name>;
        type Uri = S::Uri;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Name = S::Name;
        type Uri = Set<members::uri>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `name` field
        pub struct name(());
        ///Marker type for the `uri` field
        pub struct uri(());
    }
}

/// Builder for constructing an instance of this type
pub struct EngineSummaryViewBuilder<'a, S: engine_summary_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (Option<CowStr<'a>>, Option<CowStr<'a>>, Option<AtUri<'a>>),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> EngineSummaryView<'a> {
    /// Create a new builder for this type
    pub fn new() -> EngineSummaryViewBuilder<'a, engine_summary_view_state::Empty> {
        EngineSummaryViewBuilder::new()
    }
}

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

impl<'a, S> EngineSummaryViewBuilder<'a, S>
where
    S: engine_summary_view_state::State,
    S::Name: engine_summary_view_state::IsUnset,
{
    /// Set the `name` field (required)
    pub fn name(
        mut self,
        value: impl Into<CowStr<'a>>,
    ) -> EngineSummaryViewBuilder<'a, engine_summary_view_state::SetName<S>> {
        self._fields.0 = Option::Some(value.into());
        EngineSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: engine_summary_view_state::State> EngineSummaryViewBuilder<'a, S> {
    /// Set the `slug` field (optional)
    pub fn slug(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `slug` field to an Option value (optional)
    pub fn maybe_slug(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S> EngineSummaryViewBuilder<'a, S>
where
    S: engine_summary_view_state::State,
    S::Uri: engine_summary_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> EngineSummaryViewBuilder<'a, engine_summary_view_state::SetUri<S>> {
        self._fields.2 = Option::Some(value.into());
        EngineSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> EngineSummaryViewBuilder<'a, S>
where
    S: engine_summary_view_state::State,
    S::Name: engine_summary_view_state::IsSet,
    S::Uri: engine_summary_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> EngineSummaryView<'a> {
        EngineSummaryView {
            name: self._fields.0.unwrap(),
            slug: self._fields.1,
            uri: self._fields.2.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> EngineSummaryView<'a> {
        EngineSummaryView {
            name: self._fields.0.unwrap(),
            slug: self._fields.1,
            uri: self._fields.2.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod game_detail_view_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 {
        type Name;
        type CreatedAt;
        type Uri;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Name = Unset;
        type CreatedAt = Unset;
        type Uri = Unset;
    }
    ///State transition - sets the `name` field to Set
    pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetName<S> {}
    impl<S: State> State for SetName<S> {
        type Name = Set<members::name>;
        type CreatedAt = S::CreatedAt;
        type Uri = S::Uri;
    }
    ///State transition - sets the `created_at` field to Set
    pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
    impl<S: State> State for SetCreatedAt<S> {
        type Name = S::Name;
        type CreatedAt = Set<members::created_at>;
        type Uri = S::Uri;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Name = S::Name;
        type CreatedAt = S::CreatedAt;
        type Uri = Set<members::uri>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `name` field
        pub struct name(());
        ///Marker type for the `created_at` field
        pub struct created_at(());
        ///Marker type for the `uri` field
        pub struct uri(());
    }
}

/// Builder for constructing an instance of this type
pub struct GameDetailViewBuilder<'a, S: game_detail_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<Vec<games_gamesgamesgamesgames::ActorCreditView<'a>>>,
        Option<Vec<games_gamesgamesgamesgames::AgeRating<'a>>>,
        Option<Vec<games_gamesgamesgamesgames::AlternativeName<'a>>>,
        Option<games_gamesgamesgamesgames::ApplicationType<'a>>,
        Option<Vec<AtUri<'a>>>,
        Option<Datetime>,
        Option<Vec<AtUri<'a>>>,
        Option<games_gamesgamesgamesgames::ExternalIds<'a>>,
        Option<Vec<games_gamesgamesgamesgames::Genre<'a>>>,
        Option<Vec<CowStr<'a>>>,
        Option<Vec<games_gamesgamesgamesgames::LanguageSupport<'a>>>,
        Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
        Option<Vec<games_gamesgamesgamesgames::Mode<'a>>>,
        Option<Vec<games_gamesgamesgamesgames::MultiplayerMode<'a>>>,
        Option<CowStr<'a>>,
        Option<Vec<games_gamesgamesgamesgames::OrgCreditView<'a>>>,
        Option<AtUri<'a>>,
        Option<Vec<games_gamesgamesgamesgames::PlayerPerspective<'a>>>,
        Option<Datetime>,
        Option<Vec<games_gamesgamesgamesgames::Release<'a>>>,
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<Vec<games_gamesgamesgamesgames::Theme<'a>>>,
        Option<games_gamesgamesgamesgames::TimeToBeat<'a>>,
        Option<AtUri<'a>>,
        Option<Vec<games_gamesgamesgamesgames::ExternalVideo<'a>>>,
        Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> GameDetailView<'a> {
    /// Create a new builder for this type
    pub fn new() -> GameDetailViewBuilder<'a, game_detail_view_state::Empty> {
        GameDetailViewBuilder::new()
    }
}

impl<'a> GameDetailViewBuilder<'a, game_detail_view_state::Empty> {
    /// Create a new builder with all fields unset
    pub fn new() -> Self {
        GameDetailViewBuilder {
            _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,
            ),
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `actorCredits` field (optional)
    pub fn actor_credits(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::ActorCreditView<'a>>>>,
    ) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `actorCredits` field to an Option value (optional)
    pub fn maybe_actor_credits(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::ActorCreditView<'a>>>,
    ) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `ageRatings` field (optional)
    pub fn age_ratings(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::AgeRating<'a>>>>,
    ) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `ageRatings` field to an Option value (optional)
    pub fn maybe_age_ratings(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::AgeRating<'a>>>,
    ) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `alternativeNames` field (optional)
    pub fn alternative_names(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::AlternativeName<'a>>>>,
    ) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `alternativeNames` field to an Option value (optional)
    pub fn maybe_alternative_names(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::AlternativeName<'a>>>,
    ) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `applicationType` field (optional)
    pub fn application_type(
        mut self,
        value: impl Into<Option<games_gamesgamesgamesgames::ApplicationType<'a>>>,
    ) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `applicationType` field to an Option value (optional)
    pub fn maybe_application_type(
        mut self,
        value: Option<games_gamesgamesgamesgames::ApplicationType<'a>>,
    ) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `collections` field (optional)
    pub fn collections(mut self, value: impl Into<Option<Vec<AtUri<'a>>>>) -> Self {
        self._fields.4 = value.into();
        self
    }
    /// Set the `collections` field to an Option value (optional)
    pub fn maybe_collections(mut self, value: Option<Vec<AtUri<'a>>>) -> Self {
        self._fields.4 = value;
        self
    }
}

impl<'a, S> GameDetailViewBuilder<'a, S>
where
    S: game_detail_view_state::State,
    S::CreatedAt: game_detail_view_state::IsUnset,
{
    /// Set the `createdAt` field (required)
    pub fn created_at(
        mut self,
        value: impl Into<Datetime>,
    ) -> GameDetailViewBuilder<'a, game_detail_view_state::SetCreatedAt<S>> {
        self._fields.5 = Option::Some(value.into());
        GameDetailViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `engines` field (optional)
    pub fn engines(mut self, value: impl Into<Option<Vec<AtUri<'a>>>>) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `engines` field to an Option value (optional)
    pub fn maybe_engines(mut self, value: Option<Vec<AtUri<'a>>>) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `externalIds` field (optional)
    pub fn external_ids(
        mut self,
        value: impl Into<Option<games_gamesgamesgamesgames::ExternalIds<'a>>>,
    ) -> Self {
        self._fields.7 = value.into();
        self
    }
    /// Set the `externalIds` field to an Option value (optional)
    pub fn maybe_external_ids(
        mut self,
        value: Option<games_gamesgamesgamesgames::ExternalIds<'a>>,
    ) -> Self {
        self._fields.7 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `genres` field (optional)
    pub fn genres(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Genre<'a>>>>,
    ) -> Self {
        self._fields.8 = value.into();
        self
    }
    /// Set the `genres` field to an Option value (optional)
    pub fn maybe_genres(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Genre<'a>>>,
    ) -> Self {
        self._fields.8 = value;
        self
    }
}

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

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `languageSupports` field (optional)
    pub fn language_supports(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::LanguageSupport<'a>>>>,
    ) -> Self {
        self._fields.10 = value.into();
        self
    }
    /// Set the `languageSupports` field to an Option value (optional)
    pub fn maybe_language_supports(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::LanguageSupport<'a>>>,
    ) -> Self {
        self._fields.10 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `media` field (optional)
    pub fn media(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>>,
    ) -> Self {
        self._fields.11 = value.into();
        self
    }
    /// Set the `media` field to an Option value (optional)
    pub fn maybe_media(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    ) -> Self {
        self._fields.11 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `modes` field (optional)
    pub fn modes(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Mode<'a>>>>,
    ) -> Self {
        self._fields.12 = value.into();
        self
    }
    /// Set the `modes` field to an Option value (optional)
    pub fn maybe_modes(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Mode<'a>>>,
    ) -> Self {
        self._fields.12 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `multiplayerModes` field (optional)
    pub fn multiplayer_modes(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::MultiplayerMode<'a>>>>,
    ) -> Self {
        self._fields.13 = value.into();
        self
    }
    /// Set the `multiplayerModes` field to an Option value (optional)
    pub fn maybe_multiplayer_modes(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::MultiplayerMode<'a>>>,
    ) -> Self {
        self._fields.13 = value;
        self
    }
}

impl<'a, S> GameDetailViewBuilder<'a, S>
where
    S: game_detail_view_state::State,
    S::Name: game_detail_view_state::IsUnset,
{
    /// Set the `name` field (required)
    pub fn name(
        mut self,
        value: impl Into<CowStr<'a>>,
    ) -> GameDetailViewBuilder<'a, game_detail_view_state::SetName<S>> {
        self._fields.14 = Option::Some(value.into());
        GameDetailViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `orgCredits` field (optional)
    pub fn org_credits(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::OrgCreditView<'a>>>>,
    ) -> Self {
        self._fields.15 = value.into();
        self
    }
    /// Set the `orgCredits` field to an Option value (optional)
    pub fn maybe_org_credits(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::OrgCreditView<'a>>>,
    ) -> Self {
        self._fields.15 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `parent` field (optional)
    pub fn parent(mut self, value: impl Into<Option<AtUri<'a>>>) -> Self {
        self._fields.16 = value.into();
        self
    }
    /// Set the `parent` field to an Option value (optional)
    pub fn maybe_parent(mut self, value: Option<AtUri<'a>>) -> Self {
        self._fields.16 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `playerPerspectives` field (optional)
    pub fn player_perspectives(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::PlayerPerspective<'a>>>>,
    ) -> Self {
        self._fields.17 = value.into();
        self
    }
    /// Set the `playerPerspectives` field to an Option value (optional)
    pub fn maybe_player_perspectives(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::PlayerPerspective<'a>>>,
    ) -> Self {
        self._fields.17 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `publishedAt` field (optional)
    pub fn published_at(mut self, value: impl Into<Option<Datetime>>) -> Self {
        self._fields.18 = value.into();
        self
    }
    /// Set the `publishedAt` field to an Option value (optional)
    pub fn maybe_published_at(mut self, value: Option<Datetime>) -> Self {
        self._fields.18 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `releases` field (optional)
    pub fn releases(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Release<'a>>>>,
    ) -> Self {
        self._fields.19 = value.into();
        self
    }
    /// Set the `releases` field to an Option value (optional)
    pub fn maybe_releases(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Release<'a>>>,
    ) -> Self {
        self._fields.19 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `slug` field (optional)
    pub fn slug(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.20 = value.into();
        self
    }
    /// Set the `slug` field to an Option value (optional)
    pub fn maybe_slug(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.20 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `storyline` field (optional)
    pub fn storyline(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.21 = value.into();
        self
    }
    /// Set the `storyline` field to an Option value (optional)
    pub fn maybe_storyline(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.21 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `summary` field (optional)
    pub fn summary(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.22 = value.into();
        self
    }
    /// Set the `summary` field to an Option value (optional)
    pub fn maybe_summary(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.22 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `themes` field (optional)
    pub fn themes(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Theme<'a>>>>,
    ) -> Self {
        self._fields.23 = value.into();
        self
    }
    /// Set the `themes` field to an Option value (optional)
    pub fn maybe_themes(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Theme<'a>>>,
    ) -> Self {
        self._fields.23 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `timeToBeat` field (optional)
    pub fn time_to_beat(
        mut self,
        value: impl Into<Option<games_gamesgamesgamesgames::TimeToBeat<'a>>>,
    ) -> Self {
        self._fields.24 = value.into();
        self
    }
    /// Set the `timeToBeat` field to an Option value (optional)
    pub fn maybe_time_to_beat(
        mut self,
        value: Option<games_gamesgamesgamesgames::TimeToBeat<'a>>,
    ) -> Self {
        self._fields.24 = value;
        self
    }
}

impl<'a, S> GameDetailViewBuilder<'a, S>
where
    S: game_detail_view_state::State,
    S::Uri: game_detail_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> GameDetailViewBuilder<'a, game_detail_view_state::SetUri<S>> {
        self._fields.25 = Option::Some(value.into());
        GameDetailViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `videos` field (optional)
    pub fn videos(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::ExternalVideo<'a>>>>,
    ) -> Self {
        self._fields.26 = value.into();
        self
    }
    /// Set the `videos` field to an Option value (optional)
    pub fn maybe_videos(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::ExternalVideo<'a>>>,
    ) -> Self {
        self._fields.26 = value;
        self
    }
}

impl<'a, S: game_detail_view_state::State> GameDetailViewBuilder<'a, S> {
    /// Set the `websites` field (optional)
    pub fn websites(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Website<'a>>>>,
    ) -> Self {
        self._fields.27 = value.into();
        self
    }
    /// Set the `websites` field to an Option value (optional)
    pub fn maybe_websites(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
    ) -> Self {
        self._fields.27 = value;
        self
    }
}

impl<'a, S> GameDetailViewBuilder<'a, S>
where
    S: game_detail_view_state::State,
    S::Name: game_detail_view_state::IsSet,
    S::CreatedAt: game_detail_view_state::IsSet,
    S::Uri: game_detail_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> GameDetailView<'a> {
        GameDetailView {
            actor_credits: self._fields.0,
            age_ratings: self._fields.1,
            alternative_names: self._fields.2,
            application_type: self._fields.3,
            collections: self._fields.4,
            created_at: self._fields.5.unwrap(),
            engines: self._fields.6,
            external_ids: self._fields.7,
            genres: self._fields.8,
            keywords: self._fields.9,
            language_supports: self._fields.10,
            media: self._fields.11,
            modes: self._fields.12,
            multiplayer_modes: self._fields.13,
            name: self._fields.14.unwrap(),
            org_credits: self._fields.15,
            parent: self._fields.16,
            player_perspectives: self._fields.17,
            published_at: self._fields.18,
            releases: self._fields.19,
            slug: self._fields.20,
            storyline: self._fields.21,
            summary: self._fields.22,
            themes: self._fields.23,
            time_to_beat: self._fields.24,
            uri: self._fields.25.unwrap(),
            videos: self._fields.26,
            websites: self._fields.27,
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> GameDetailView<'a> {
        GameDetailView {
            actor_credits: self._fields.0,
            age_ratings: self._fields.1,
            alternative_names: self._fields.2,
            application_type: self._fields.3,
            collections: self._fields.4,
            created_at: self._fields.5.unwrap(),
            engines: self._fields.6,
            external_ids: self._fields.7,
            genres: self._fields.8,
            keywords: self._fields.9,
            language_supports: self._fields.10,
            media: self._fields.11,
            modes: self._fields.12,
            multiplayer_modes: self._fields.13,
            name: self._fields.14.unwrap(),
            org_credits: self._fields.15,
            parent: self._fields.16,
            player_perspectives: self._fields.17,
            published_at: self._fields.18,
            releases: self._fields.19,
            slug: self._fields.20,
            storyline: self._fields.21,
            summary: self._fields.22,
            themes: self._fields.23,
            time_to_beat: self._fields.24,
            uri: self._fields.25.unwrap(),
            videos: self._fields.26,
            websites: self._fields.27,
            extra_data: Some(extra_data),
        }
    }
}

pub mod game_feed_view_item_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 {
        type Game;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Game = Unset;
    }
    ///State transition - sets the `game` field to Set
    pub struct SetGame<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetGame<S> {}
    impl<S: State> State for SetGame<S> {
        type Game = Set<members::game>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `game` field
        pub struct game(());
    }
}

/// Builder for constructing an instance of this type
pub struct GameFeedViewItemBuilder<'a, S: game_feed_view_item_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (Option<CowStr<'a>>, Option<games_gamesgamesgamesgames::GameView<'a>>),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> GameFeedViewItem<'a> {
    /// Create a new builder for this type
    pub fn new() -> GameFeedViewItemBuilder<'a, game_feed_view_item_state::Empty> {
        GameFeedViewItemBuilder::new()
    }
}

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

impl<'a, S: game_feed_view_item_state::State> GameFeedViewItemBuilder<'a, S> {
    /// Set the `feedContext` field (optional)
    pub fn feed_context(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `feedContext` field to an Option value (optional)
    pub fn maybe_feed_context(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S> GameFeedViewItemBuilder<'a, S>
where
    S: game_feed_view_item_state::State,
    S::Game: game_feed_view_item_state::IsUnset,
{
    /// Set the `game` field (required)
    pub fn game(
        mut self,
        value: impl Into<games_gamesgamesgamesgames::GameView<'a>>,
    ) -> GameFeedViewItemBuilder<'a, game_feed_view_item_state::SetGame<S>> {
        self._fields.1 = Option::Some(value.into());
        GameFeedViewItemBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> GameFeedViewItemBuilder<'a, S>
where
    S: game_feed_view_item_state::State,
    S::Game: game_feed_view_item_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> GameFeedViewItem<'a> {
        GameFeedViewItem {
            feed_context: self._fields.0,
            game: self._fields.1.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> GameFeedViewItem<'a> {
        GameFeedViewItem {
            feed_context: self._fields.0,
            game: self._fields.1.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod game_summary_view_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 {
        type Name;
        type Uri;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Name = Unset;
        type Uri = Unset;
    }
    ///State transition - sets the `name` field to Set
    pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetName<S> {}
    impl<S: State> State for SetName<S> {
        type Name = Set<members::name>;
        type Uri = S::Uri;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Name = S::Name;
        type Uri = Set<members::uri>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `name` field
        pub struct name(());
        ///Marker type for the `uri` field
        pub struct uri(());
    }
}

/// Builder for constructing an instance of this type
pub struct GameSummaryViewBuilder<'a, S: game_summary_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<games_gamesgamesgamesgames::ApplicationType<'a>>,
        Option<i64>,
        Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<AtUri<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> GameSummaryView<'a> {
    /// Create a new builder for this type
    pub fn new() -> GameSummaryViewBuilder<'a, game_summary_view_state::Empty> {
        GameSummaryViewBuilder::new()
    }
}

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

impl<'a, S: game_summary_view_state::State> GameSummaryViewBuilder<'a, S> {
    /// Set the `applicationType` field (optional)
    pub fn application_type(
        mut self,
        value: impl Into<Option<games_gamesgamesgamesgames::ApplicationType<'a>>>,
    ) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `applicationType` field to an Option value (optional)
    pub fn maybe_application_type(
        mut self,
        value: Option<games_gamesgamesgamesgames::ApplicationType<'a>>,
    ) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S: game_summary_view_state::State> GameSummaryViewBuilder<'a, S> {
    /// Set the `firstReleaseDate` field (optional)
    pub fn first_release_date(mut self, value: impl Into<Option<i64>>) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `firstReleaseDate` field to an Option value (optional)
    pub fn maybe_first_release_date(mut self, value: Option<i64>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S: game_summary_view_state::State> GameSummaryViewBuilder<'a, S> {
    /// Set the `media` field (optional)
    pub fn media(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>>,
    ) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `media` field to an Option value (optional)
    pub fn maybe_media(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    ) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S> GameSummaryViewBuilder<'a, S>
where
    S: game_summary_view_state::State,
    S::Name: game_summary_view_state::IsUnset,
{
    /// Set the `name` field (required)
    pub fn name(
        mut self,
        value: impl Into<CowStr<'a>>,
    ) -> GameSummaryViewBuilder<'a, game_summary_view_state::SetName<S>> {
        self._fields.3 = Option::Some(value.into());
        GameSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: game_summary_view_state::State> GameSummaryViewBuilder<'a, S> {
    /// Set the `slug` field (optional)
    pub fn slug(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.4 = value.into();
        self
    }
    /// Set the `slug` field to an Option value (optional)
    pub fn maybe_slug(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.4 = value;
        self
    }
}

impl<'a, S: game_summary_view_state::State> GameSummaryViewBuilder<'a, S> {
    /// Set the `summary` field (optional)
    pub fn summary(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.5 = value.into();
        self
    }
    /// Set the `summary` field to an Option value (optional)
    pub fn maybe_summary(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.5 = value;
        self
    }
}

impl<'a, S> GameSummaryViewBuilder<'a, S>
where
    S: game_summary_view_state::State,
    S::Uri: game_summary_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> GameSummaryViewBuilder<'a, game_summary_view_state::SetUri<S>> {
        self._fields.6 = Option::Some(value.into());
        GameSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> GameSummaryViewBuilder<'a, S>
where
    S: game_summary_view_state::State,
    S::Name: game_summary_view_state::IsSet,
    S::Uri: game_summary_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> GameSummaryView<'a> {
        GameSummaryView {
            application_type: self._fields.0,
            first_release_date: self._fields.1,
            media: self._fields.2,
            name: self._fields.3.unwrap(),
            slug: self._fields.4,
            summary: self._fields.5,
            uri: self._fields.6.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> GameSummaryView<'a> {
        GameSummaryView {
            application_type: self._fields.0,
            first_release_date: self._fields.1,
            media: self._fields.2,
            name: self._fields.3.unwrap(),
            slug: self._fields.4,
            summary: self._fields.5,
            uri: self._fields.6.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod game_view_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 {
        type ApplicationType;
        type Uri;
        type Name;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type ApplicationType = Unset;
        type Uri = Unset;
        type Name = Unset;
    }
    ///State transition - sets the `application_type` field to Set
    pub struct SetApplicationType<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetApplicationType<S> {}
    impl<S: State> State for SetApplicationType<S> {
        type ApplicationType = Set<members::application_type>;
        type Uri = S::Uri;
        type Name = S::Name;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type ApplicationType = S::ApplicationType;
        type Uri = Set<members::uri>;
        type Name = S::Name;
    }
    ///State transition - sets the `name` field to Set
    pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetName<S> {}
    impl<S: State> State for SetName<S> {
        type ApplicationType = S::ApplicationType;
        type Uri = S::Uri;
        type Name = Set<members::name>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `application_type` field
        pub struct application_type(());
        ///Marker type for the `uri` field
        pub struct uri(());
        ///Marker type for the `name` field
        pub struct name(());
    }
}

/// Builder for constructing an instance of this type
pub struct GameViewBuilder<'a, S: game_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<games_gamesgamesgamesgames::ApplicationType<'a>>,
        Option<Vec<games_gamesgamesgamesgames::Genre<'a>>>,
        Option<i64>,
        Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
        Option<CowStr<'a>>,
        Option<Vec<games_gamesgamesgamesgames::Release<'a>>>,
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<Vec<games_gamesgamesgamesgames::Theme<'a>>>,
        Option<AtUri<'a>>,
        Option<games_gamesgamesgamesgames::ViewerState<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> GameView<'a> {
    /// Create a new builder for this type
    pub fn new() -> GameViewBuilder<'a, game_view_state::Empty> {
        GameViewBuilder::new()
    }
}

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

impl<'a, S> GameViewBuilder<'a, S>
where
    S: game_view_state::State,
    S::ApplicationType: game_view_state::IsUnset,
{
    /// Set the `applicationType` field (required)
    pub fn application_type(
        mut self,
        value: impl Into<games_gamesgamesgamesgames::ApplicationType<'a>>,
    ) -> GameViewBuilder<'a, game_view_state::SetApplicationType<S>> {
        self._fields.0 = Option::Some(value.into());
        GameViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: game_view_state::State> GameViewBuilder<'a, S> {
    /// Set the `genres` field (optional)
    pub fn genres(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Genre<'a>>>>,
    ) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `genres` field to an Option value (optional)
    pub fn maybe_genres(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Genre<'a>>>,
    ) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S: game_view_state::State> GameViewBuilder<'a, S> {
    /// Set the `likeCount` field (optional)
    pub fn like_count(mut self, value: impl Into<Option<i64>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `likeCount` field to an Option value (optional)
    pub fn maybe_like_count(mut self, value: Option<i64>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S: game_view_state::State> GameViewBuilder<'a, S> {
    /// Set the `media` field (optional)
    pub fn media(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>>,
    ) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `media` field to an Option value (optional)
    pub fn maybe_media(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    ) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<'a, S> GameViewBuilder<'a, S>
where
    S: game_view_state::State,
    S::Name: game_view_state::IsUnset,
{
    /// Set the `name` field (required)
    pub fn name(
        mut self,
        value: impl Into<CowStr<'a>>,
    ) -> GameViewBuilder<'a, game_view_state::SetName<S>> {
        self._fields.4 = Option::Some(value.into());
        GameViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: game_view_state::State> GameViewBuilder<'a, S> {
    /// Set the `releases` field (optional)
    pub fn releases(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Release<'a>>>>,
    ) -> Self {
        self._fields.5 = value.into();
        self
    }
    /// Set the `releases` field to an Option value (optional)
    pub fn maybe_releases(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Release<'a>>>,
    ) -> Self {
        self._fields.5 = value;
        self
    }
}

impl<'a, S: game_view_state::State> GameViewBuilder<'a, S> {
    /// Set the `slug` field (optional)
    pub fn slug(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `slug` field to an Option value (optional)
    pub fn maybe_slug(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<'a, S: game_view_state::State> GameViewBuilder<'a, S> {
    /// Set the `summary` field (optional)
    pub fn summary(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.7 = value.into();
        self
    }
    /// Set the `summary` field to an Option value (optional)
    pub fn maybe_summary(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.7 = value;
        self
    }
}

impl<'a, S: game_view_state::State> GameViewBuilder<'a, S> {
    /// Set the `themes` field (optional)
    pub fn themes(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Theme<'a>>>>,
    ) -> Self {
        self._fields.8 = value.into();
        self
    }
    /// Set the `themes` field to an Option value (optional)
    pub fn maybe_themes(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Theme<'a>>>,
    ) -> Self {
        self._fields.8 = value;
        self
    }
}

impl<'a, S> GameViewBuilder<'a, S>
where
    S: game_view_state::State,
    S::Uri: game_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> GameViewBuilder<'a, game_view_state::SetUri<S>> {
        self._fields.9 = Option::Some(value.into());
        GameViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: game_view_state::State> GameViewBuilder<'a, S> {
    /// Set the `viewer` field (optional)
    pub fn viewer(
        mut self,
        value: impl Into<Option<games_gamesgamesgamesgames::ViewerState<'a>>>,
    ) -> Self {
        self._fields.10 = value.into();
        self
    }
    /// Set the `viewer` field to an Option value (optional)
    pub fn maybe_viewer(
        mut self,
        value: Option<games_gamesgamesgamesgames::ViewerState<'a>>,
    ) -> Self {
        self._fields.10 = value;
        self
    }
}

impl<'a, S> GameViewBuilder<'a, S>
where
    S: game_view_state::State,
    S::ApplicationType: game_view_state::IsSet,
    S::Uri: game_view_state::IsSet,
    S::Name: game_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> GameView<'a> {
        GameView {
            application_type: self._fields.0.unwrap(),
            genres: self._fields.1,
            like_count: self._fields.2,
            media: self._fields.3,
            name: self._fields.4.unwrap(),
            releases: self._fields.5,
            slug: self._fields.6,
            summary: self._fields.7,
            themes: self._fields.8,
            uri: self._fields.9.unwrap(),
            viewer: self._fields.10,
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> GameView<'a> {
        GameView {
            application_type: self._fields.0.unwrap(),
            genres: self._fields.1,
            like_count: self._fields.2,
            media: self._fields.3,
            name: self._fields.4.unwrap(),
            releases: self._fields.5,
            slug: self._fields.6,
            summary: self._fields.7,
            themes: self._fields.8,
            uri: self._fields.9.unwrap(),
            viewer: self._fields.10,
            extra_data: Some(extra_data),
        }
    }
}

pub mod org_credit_view_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 {
        type Uri;
        type Roles;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Uri = Unset;
        type Roles = Unset;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Uri = Set<members::uri>;
        type Roles = S::Roles;
    }
    ///State transition - sets the `roles` field to Set
    pub struct SetRoles<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetRoles<S> {}
    impl<S: State> State for SetRoles<S> {
        type Uri = S::Uri;
        type Roles = Set<members::roles>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `uri` field
        pub struct uri(());
        ///Marker type for the `roles` field
        pub struct roles(());
    }
}

/// Builder for constructing an instance of this type
pub struct OrgCreditViewBuilder<'a, S: org_credit_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<CowStr<'a>>,
        Option<AtUri<'a>>,
        Option<Vec<games_gamesgamesgamesgames::CompanyRole<'a>>>,
        Option<AtUri<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> OrgCreditView<'a> {
    /// Create a new builder for this type
    pub fn new() -> OrgCreditViewBuilder<'a, org_credit_view_state::Empty> {
        OrgCreditViewBuilder::new()
    }
}

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

impl<'a, S: org_credit_view_state::State> OrgCreditViewBuilder<'a, S> {
    /// Set the `displayName` field (optional)
    pub fn display_name(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `displayName` field to an Option value (optional)
    pub fn maybe_display_name(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S: org_credit_view_state::State> OrgCreditViewBuilder<'a, S> {
    /// Set the `orgUri` field (optional)
    pub fn org_uri(mut self, value: impl Into<Option<AtUri<'a>>>) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `orgUri` field to an Option value (optional)
    pub fn maybe_org_uri(mut self, value: Option<AtUri<'a>>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S> OrgCreditViewBuilder<'a, S>
where
    S: org_credit_view_state::State,
    S::Roles: org_credit_view_state::IsUnset,
{
    /// Set the `roles` field (required)
    pub fn roles(
        mut self,
        value: impl Into<Vec<games_gamesgamesgamesgames::CompanyRole<'a>>>,
    ) -> OrgCreditViewBuilder<'a, org_credit_view_state::SetRoles<S>> {
        self._fields.2 = Option::Some(value.into());
        OrgCreditViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> OrgCreditViewBuilder<'a, S>
where
    S: org_credit_view_state::State,
    S::Uri: org_credit_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> OrgCreditViewBuilder<'a, org_credit_view_state::SetUri<S>> {
        self._fields.3 = Option::Some(value.into());
        OrgCreditViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> OrgCreditViewBuilder<'a, S>
where
    S: org_credit_view_state::State,
    S::Uri: org_credit_view_state::IsSet,
    S::Roles: org_credit_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> OrgCreditView<'a> {
        OrgCreditView {
            display_name: self._fields.0,
            org_uri: self._fields.1,
            roles: self._fields.2.unwrap(),
            uri: self._fields.3.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> OrgCreditView<'a> {
        OrgCreditView {
            display_name: self._fields.0,
            org_uri: self._fields.1,
            roles: self._fields.2.unwrap(),
            uri: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod org_profile_detail_view_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 {
        type Did;
        type Uri;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Did = Unset;
        type Uri = Unset;
    }
    ///State transition - sets the `did` field to Set
    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetDid<S> {}
    impl<S: State> State for SetDid<S> {
        type Did = Set<members::did>;
        type Uri = S::Uri;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Did = S::Did;
        type Uri = Set<members::uri>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `did` field
        pub struct did(());
        ///Marker type for the `uri` field
        pub struct uri(());
    }
}

/// Builder for constructing an instance of this type
pub struct OrgProfileDetailViewBuilder<'a, S: org_profile_detail_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<BlobRef<'a>>,
        Option<CowStr<'a>>,
        Option<Datetime>,
        Option<CowStr<'a>>,
        Option<Vec<Facet<'a>>>,
        Option<Did<'a>>,
        Option<CowStr<'a>>,
        Option<Datetime>,
        Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
        Option<AtUri<'a>>,
        Option<OrgProfileDetailViewStatus<'a>>,
        Option<AtUri<'a>>,
        Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> OrgProfileDetailView<'a> {
    /// Create a new builder for this type
    pub fn new() -> OrgProfileDetailViewBuilder<
        'a,
        org_profile_detail_view_state::Empty,
    > {
        OrgProfileDetailViewBuilder::new()
    }
}

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

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `avatar` field (optional)
    pub fn avatar(mut self, value: impl Into<Option<BlobRef<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `avatar` field to an Option value (optional)
    pub fn maybe_avatar(mut self, value: Option<BlobRef<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `country` field (optional)
    pub fn country(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `country` field to an Option value (optional)
    pub fn maybe_country(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `createdAt` field (optional)
    pub fn created_at(mut self, value: impl Into<Option<Datetime>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `createdAt` field to an Option value (optional)
    pub fn maybe_created_at(mut self, value: Option<Datetime>) -> Self {
        self._fields.2 = value;
        self
    }
}

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

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `descriptionFacets` field (optional)
    pub fn description_facets(
        mut self,
        value: impl Into<Option<Vec<Facet<'a>>>>,
    ) -> Self {
        self._fields.4 = value.into();
        self
    }
    /// Set the `descriptionFacets` field to an Option value (optional)
    pub fn maybe_description_facets(mut self, value: Option<Vec<Facet<'a>>>) -> Self {
        self._fields.4 = value;
        self
    }
}

impl<'a, S> OrgProfileDetailViewBuilder<'a, S>
where
    S: org_profile_detail_view_state::State,
    S::Did: org_profile_detail_view_state::IsUnset,
{
    /// Set the `did` field (required)
    pub fn did(
        mut self,
        value: impl Into<Did<'a>>,
    ) -> OrgProfileDetailViewBuilder<'a, org_profile_detail_view_state::SetDid<S>> {
        self._fields.5 = Option::Some(value.into());
        OrgProfileDetailViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `displayName` field (optional)
    pub fn display_name(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `displayName` field to an Option value (optional)
    pub fn maybe_display_name(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `foundedAt` field (optional)
    pub fn founded_at(mut self, value: impl Into<Option<Datetime>>) -> Self {
        self._fields.7 = value.into();
        self
    }
    /// Set the `foundedAt` field to an Option value (optional)
    pub fn maybe_founded_at(mut self, value: Option<Datetime>) -> Self {
        self._fields.7 = value;
        self
    }
}

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `media` field (optional)
    pub fn media(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>>,
    ) -> Self {
        self._fields.8 = value.into();
        self
    }
    /// Set the `media` field to an Option value (optional)
    pub fn maybe_media(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::MediaItem<'a>>>,
    ) -> Self {
        self._fields.8 = value;
        self
    }
}

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `parent` field (optional)
    pub fn parent(mut self, value: impl Into<Option<AtUri<'a>>>) -> Self {
        self._fields.9 = value.into();
        self
    }
    /// Set the `parent` field to an Option value (optional)
    pub fn maybe_parent(mut self, value: Option<AtUri<'a>>) -> Self {
        self._fields.9 = value;
        self
    }
}

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `status` field (optional)
    pub fn status(
        mut self,
        value: impl Into<Option<OrgProfileDetailViewStatus<'a>>>,
    ) -> Self {
        self._fields.10 = value.into();
        self
    }
    /// Set the `status` field to an Option value (optional)
    pub fn maybe_status(
        mut self,
        value: Option<OrgProfileDetailViewStatus<'a>>,
    ) -> Self {
        self._fields.10 = value;
        self
    }
}

impl<'a, S> OrgProfileDetailViewBuilder<'a, S>
where
    S: org_profile_detail_view_state::State,
    S::Uri: org_profile_detail_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> OrgProfileDetailViewBuilder<'a, org_profile_detail_view_state::SetUri<S>> {
        self._fields.11 = Option::Some(value.into());
        OrgProfileDetailViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: org_profile_detail_view_state::State> OrgProfileDetailViewBuilder<'a, S> {
    /// Set the `websites` field (optional)
    pub fn websites(
        mut self,
        value: impl Into<Option<Vec<games_gamesgamesgamesgames::Website<'a>>>>,
    ) -> Self {
        self._fields.12 = value.into();
        self
    }
    /// Set the `websites` field to an Option value (optional)
    pub fn maybe_websites(
        mut self,
        value: Option<Vec<games_gamesgamesgamesgames::Website<'a>>>,
    ) -> Self {
        self._fields.12 = value;
        self
    }
}

impl<'a, S> OrgProfileDetailViewBuilder<'a, S>
where
    S: org_profile_detail_view_state::State,
    S::Did: org_profile_detail_view_state::IsSet,
    S::Uri: org_profile_detail_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> OrgProfileDetailView<'a> {
        OrgProfileDetailView {
            avatar: self._fields.0,
            country: self._fields.1,
            created_at: self._fields.2,
            description: self._fields.3,
            description_facets: self._fields.4,
            did: self._fields.5.unwrap(),
            display_name: self._fields.6,
            founded_at: self._fields.7,
            media: self._fields.8,
            parent: self._fields.9,
            status: self._fields.10,
            uri: self._fields.11.unwrap(),
            websites: self._fields.12,
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> OrgProfileDetailView<'a> {
        OrgProfileDetailView {
            avatar: self._fields.0,
            country: self._fields.1,
            created_at: self._fields.2,
            description: self._fields.3,
            description_facets: self._fields.4,
            did: self._fields.5.unwrap(),
            display_name: self._fields.6,
            founded_at: self._fields.7,
            media: self._fields.8,
            parent: self._fields.9,
            status: self._fields.10,
            uri: self._fields.11.unwrap(),
            websites: self._fields.12,
            extra_data: Some(extra_data),
        }
    }
}

pub mod org_profile_summary_view_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 {
        type Uri;
        type Did;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Uri = Unset;
        type Did = Unset;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Uri = Set<members::uri>;
        type Did = S::Did;
    }
    ///State transition - sets the `did` field to Set
    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetDid<S> {}
    impl<S: State> State for SetDid<S> {
        type Uri = S::Uri;
        type Did = Set<members::did>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `uri` field
        pub struct uri(());
        ///Marker type for the `did` field
        pub struct did(());
    }
}

/// Builder for constructing an instance of this type
pub struct OrgProfileSummaryViewBuilder<'a, S: org_profile_summary_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<BlobRef<'a>>,
        Option<Did<'a>>,
        Option<CowStr<'a>>,
        Option<AtUri<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> OrgProfileSummaryView<'a> {
    /// Create a new builder for this type
    pub fn new() -> OrgProfileSummaryViewBuilder<
        'a,
        org_profile_summary_view_state::Empty,
    > {
        OrgProfileSummaryViewBuilder::new()
    }
}

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

impl<'a, S: org_profile_summary_view_state::State> OrgProfileSummaryViewBuilder<'a, S> {
    /// Set the `avatar` field (optional)
    pub fn avatar(mut self, value: impl Into<Option<BlobRef<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `avatar` field to an Option value (optional)
    pub fn maybe_avatar(mut self, value: Option<BlobRef<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S> OrgProfileSummaryViewBuilder<'a, S>
where
    S: org_profile_summary_view_state::State,
    S::Did: org_profile_summary_view_state::IsUnset,
{
    /// Set the `did` field (required)
    pub fn did(
        mut self,
        value: impl Into<Did<'a>>,
    ) -> OrgProfileSummaryViewBuilder<'a, org_profile_summary_view_state::SetDid<S>> {
        self._fields.1 = Option::Some(value.into());
        OrgProfileSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: org_profile_summary_view_state::State> OrgProfileSummaryViewBuilder<'a, S> {
    /// Set the `displayName` field (optional)
    pub fn display_name(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `displayName` field to an Option value (optional)
    pub fn maybe_display_name(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S> OrgProfileSummaryViewBuilder<'a, S>
where
    S: org_profile_summary_view_state::State,
    S::Uri: org_profile_summary_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> OrgProfileSummaryViewBuilder<'a, org_profile_summary_view_state::SetUri<S>> {
        self._fields.3 = Option::Some(value.into());
        OrgProfileSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> OrgProfileSummaryViewBuilder<'a, S>
where
    S: org_profile_summary_view_state::State,
    S::Uri: org_profile_summary_view_state::IsSet,
    S::Did: org_profile_summary_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> OrgProfileSummaryView<'a> {
        OrgProfileSummaryView {
            avatar: self._fields.0,
            did: self._fields.1.unwrap(),
            display_name: self._fields.2,
            uri: self._fields.3.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> OrgProfileSummaryView<'a> {
        OrgProfileSummaryView {
            avatar: self._fields.0,
            did: self._fields.1.unwrap(),
            display_name: self._fields.2,
            uri: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod platform_features_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 {
        type Platform;
        type Features;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Platform = Unset;
        type Features = Unset;
    }
    ///State transition - sets the `platform` field to Set
    pub struct SetPlatform<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetPlatform<S> {}
    impl<S: State> State for SetPlatform<S> {
        type Platform = Set<members::platform>;
        type Features = S::Features;
    }
    ///State transition - sets the `features` field to Set
    pub struct SetFeatures<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetFeatures<S> {}
    impl<S: State> State for SetFeatures<S> {
        type Platform = S::Platform;
        type Features = Set<members::features>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `platform` field
        pub struct platform(());
        ///Marker type for the `features` field
        pub struct features(());
    }
}

/// Builder for constructing an instance of this type
pub struct PlatformFeaturesBuilder<'a, S: platform_features_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (Option<Vec<CowStr<'a>>>, Option<PlatformFeaturesPlatform<'a>>),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> PlatformFeatures<'a> {
    /// Create a new builder for this type
    pub fn new() -> PlatformFeaturesBuilder<'a, platform_features_state::Empty> {
        PlatformFeaturesBuilder::new()
    }
}

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

impl<'a, S> PlatformFeaturesBuilder<'a, S>
where
    S: platform_features_state::State,
    S::Features: platform_features_state::IsUnset,
{
    /// Set the `features` field (required)
    pub fn features(
        mut self,
        value: impl Into<Vec<CowStr<'a>>>,
    ) -> PlatformFeaturesBuilder<'a, platform_features_state::SetFeatures<S>> {
        self._fields.0 = Option::Some(value.into());
        PlatformFeaturesBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> PlatformFeaturesBuilder<'a, S>
where
    S: platform_features_state::State,
    S::Platform: platform_features_state::IsUnset,
{
    /// Set the `platform` field (required)
    pub fn platform(
        mut self,
        value: impl Into<PlatformFeaturesPlatform<'a>>,
    ) -> PlatformFeaturesBuilder<'a, platform_features_state::SetPlatform<S>> {
        self._fields.1 = Option::Some(value.into());
        PlatformFeaturesBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> PlatformFeaturesBuilder<'a, S>
where
    S: platform_features_state::State,
    S::Platform: platform_features_state::IsSet,
    S::Features: platform_features_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> PlatformFeatures<'a> {
        PlatformFeatures {
            features: self._fields.0.unwrap(),
            platform: self._fields.1.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> PlatformFeatures<'a> {
        PlatformFeatures {
            features: self._fields.0.unwrap(),
            platform: self._fields.1.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod platform_summary_view_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 {
        type Name;
        type Uri;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Name = Unset;
        type Uri = Unset;
    }
    ///State transition - sets the `name` field to Set
    pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetName<S> {}
    impl<S: State> State for SetName<S> {
        type Name = Set<members::name>;
        type Uri = S::Uri;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type Name = S::Name;
        type Uri = Set<members::uri>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `name` field
        pub struct name(());
        ///Marker type for the `uri` field
        pub struct uri(());
    }
}

/// Builder for constructing an instance of this type
pub struct PlatformSummaryViewBuilder<'a, S: platform_summary_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<CowStr<'a>>,
        Option<games_gamesgamesgamesgames::PlatformCategory<'a>>,
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<AtUri<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> PlatformSummaryView<'a> {
    /// Create a new builder for this type
    pub fn new() -> PlatformSummaryViewBuilder<'a, platform_summary_view_state::Empty> {
        PlatformSummaryViewBuilder::new()
    }
}

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

impl<'a, S: platform_summary_view_state::State> PlatformSummaryViewBuilder<'a, S> {
    /// Set the `abbreviation` field (optional)
    pub fn abbreviation(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `abbreviation` field to an Option value (optional)
    pub fn maybe_abbreviation(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S: platform_summary_view_state::State> PlatformSummaryViewBuilder<'a, S> {
    /// Set the `category` field (optional)
    pub fn category(
        mut self,
        value: impl Into<Option<games_gamesgamesgamesgames::PlatformCategory<'a>>>,
    ) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `category` field to an Option value (optional)
    pub fn maybe_category(
        mut self,
        value: Option<games_gamesgamesgamesgames::PlatformCategory<'a>>,
    ) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<'a, S> PlatformSummaryViewBuilder<'a, S>
where
    S: platform_summary_view_state::State,
    S::Name: platform_summary_view_state::IsUnset,
{
    /// Set the `name` field (required)
    pub fn name(
        mut self,
        value: impl Into<CowStr<'a>>,
    ) -> PlatformSummaryViewBuilder<'a, platform_summary_view_state::SetName<S>> {
        self._fields.2 = Option::Some(value.into());
        PlatformSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: platform_summary_view_state::State> PlatformSummaryViewBuilder<'a, S> {
    /// Set the `slug` field (optional)
    pub fn slug(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `slug` field to an Option value (optional)
    pub fn maybe_slug(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<'a, S> PlatformSummaryViewBuilder<'a, S>
where
    S: platform_summary_view_state::State,
    S::Uri: platform_summary_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> PlatformSummaryViewBuilder<'a, platform_summary_view_state::SetUri<S>> {
        self._fields.4 = Option::Some(value.into());
        PlatformSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> PlatformSummaryViewBuilder<'a, S>
where
    S: platform_summary_view_state::State,
    S::Name: platform_summary_view_state::IsSet,
    S::Uri: platform_summary_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> PlatformSummaryView<'a> {
        PlatformSummaryView {
            abbreviation: self._fields.0,
            category: self._fields.1,
            name: self._fields.2.unwrap(),
            slug: self._fields.3,
            uri: self._fields.4.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> PlatformSummaryView<'a> {
        PlatformSummaryView {
            abbreviation: self._fields.0,
            category: self._fields.1,
            name: self._fields.2.unwrap(),
            slug: self._fields.3,
            uri: self._fields.4.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod profile_summary_view_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 {
        type ProfileType;
        type Did;
        type Uri;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type ProfileType = Unset;
        type Did = Unset;
        type Uri = Unset;
    }
    ///State transition - sets the `profile_type` field to Set
    pub struct SetProfileType<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetProfileType<S> {}
    impl<S: State> State for SetProfileType<S> {
        type ProfileType = Set<members::profile_type>;
        type Did = S::Did;
        type Uri = S::Uri;
    }
    ///State transition - sets the `did` field to Set
    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetDid<S> {}
    impl<S: State> State for SetDid<S> {
        type ProfileType = S::ProfileType;
        type Did = Set<members::did>;
        type Uri = S::Uri;
    }
    ///State transition - sets the `uri` field to Set
    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUri<S> {}
    impl<S: State> State for SetUri<S> {
        type ProfileType = S::ProfileType;
        type Did = S::Did;
        type Uri = Set<members::uri>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `profile_type` field
        pub struct profile_type(());
        ///Marker type for the `did` field
        pub struct did(());
        ///Marker type for the `uri` field
        pub struct uri(());
    }
}

/// Builder for constructing an instance of this type
pub struct ProfileSummaryViewBuilder<'a, S: profile_summary_view_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<BlobRef<'a>>,
        Option<Did<'a>>,
        Option<CowStr<'a>>,
        Option<ProfileSummaryViewProfileType<'a>>,
        Option<AtUri<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> ProfileSummaryView<'a> {
    /// Create a new builder for this type
    pub fn new() -> ProfileSummaryViewBuilder<'a, profile_summary_view_state::Empty> {
        ProfileSummaryViewBuilder::new()
    }
}

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

impl<'a, S: profile_summary_view_state::State> ProfileSummaryViewBuilder<'a, S> {
    /// Set the `avatar` field (optional)
    pub fn avatar(mut self, value: impl Into<Option<BlobRef<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `avatar` field to an Option value (optional)
    pub fn maybe_avatar(mut self, value: Option<BlobRef<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S> ProfileSummaryViewBuilder<'a, S>
where
    S: profile_summary_view_state::State,
    S::Did: profile_summary_view_state::IsUnset,
{
    /// Set the `did` field (required)
    pub fn did(
        mut self,
        value: impl Into<Did<'a>>,
    ) -> ProfileSummaryViewBuilder<'a, profile_summary_view_state::SetDid<S>> {
        self._fields.1 = Option::Some(value.into());
        ProfileSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: profile_summary_view_state::State> ProfileSummaryViewBuilder<'a, S> {
    /// Set the `displayName` field (optional)
    pub fn display_name(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `displayName` field to an Option value (optional)
    pub fn maybe_display_name(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S> ProfileSummaryViewBuilder<'a, S>
where
    S: profile_summary_view_state::State,
    S::ProfileType: profile_summary_view_state::IsUnset,
{
    /// Set the `profileType` field (required)
    pub fn profile_type(
        mut self,
        value: impl Into<ProfileSummaryViewProfileType<'a>>,
    ) -> ProfileSummaryViewBuilder<'a, profile_summary_view_state::SetProfileType<S>> {
        self._fields.3 = Option::Some(value.into());
        ProfileSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> ProfileSummaryViewBuilder<'a, S>
where
    S: profile_summary_view_state::State,
    S::Uri: profile_summary_view_state::IsUnset,
{
    /// Set the `uri` field (required)
    pub fn uri(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> ProfileSummaryViewBuilder<'a, profile_summary_view_state::SetUri<S>> {
        self._fields.4 = Option::Some(value.into());
        ProfileSummaryViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> ProfileSummaryViewBuilder<'a, S>
where
    S: profile_summary_view_state::State,
    S::ProfileType: profile_summary_view_state::IsSet,
    S::Did: profile_summary_view_state::IsSet,
    S::Uri: profile_summary_view_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> ProfileSummaryView<'a> {
        ProfileSummaryView {
            avatar: self._fields.0,
            did: self._fields.1.unwrap(),
            display_name: self._fields.2,
            profile_type: self._fields.3.unwrap(),
            uri: self._fields.4.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> ProfileSummaryView<'a> {
        ProfileSummaryView {
            avatar: self._fields.0,
            did: self._fields.1.unwrap(),
            display_name: self._fields.2,
            profile_type: self._fields.3.unwrap(),
            uri: self._fields.4.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod skeleton_game_feed_item_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 {
        type Game;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Game = Unset;
    }
    ///State transition - sets the `game` field to Set
    pub struct SetGame<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetGame<S> {}
    impl<S: State> State for SetGame<S> {
        type Game = Set<members::game>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `game` field
        pub struct game(());
    }
}

/// Builder for constructing an instance of this type
pub struct SkeletonGameFeedItemBuilder<'a, S: skeleton_game_feed_item_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (Option<CowStr<'a>>, Option<AtUri<'a>>),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> SkeletonGameFeedItem<'a> {
    /// Create a new builder for this type
    pub fn new() -> SkeletonGameFeedItemBuilder<
        'a,
        skeleton_game_feed_item_state::Empty,
    > {
        SkeletonGameFeedItemBuilder::new()
    }
}

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

impl<'a, S: skeleton_game_feed_item_state::State> SkeletonGameFeedItemBuilder<'a, S> {
    /// Set the `feedContext` field (optional)
    pub fn feed_context(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `feedContext` field to an Option value (optional)
    pub fn maybe_feed_context(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S> SkeletonGameFeedItemBuilder<'a, S>
where
    S: skeleton_game_feed_item_state::State,
    S::Game: skeleton_game_feed_item_state::IsUnset,
{
    /// Set the `game` field (required)
    pub fn game(
        mut self,
        value: impl Into<AtUri<'a>>,
    ) -> SkeletonGameFeedItemBuilder<'a, skeleton_game_feed_item_state::SetGame<S>> {
        self._fields.1 = Option::Some(value.into());
        SkeletonGameFeedItemBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> SkeletonGameFeedItemBuilder<'a, S>
where
    S: skeleton_game_feed_item_state::State,
    S::Game: skeleton_game_feed_item_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> SkeletonGameFeedItem<'a> {
        SkeletonGameFeedItem {
            feed_context: self._fields.0,
            game: self._fields.1.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> SkeletonGameFeedItem<'a> {
        SkeletonGameFeedItem {
            feed_context: self._fields.0,
            game: self._fields.1.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod website_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 {
        type Url;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Url = Unset;
    }
    ///State transition - sets the `url` field to Set
    pub struct SetUrl<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetUrl<S> {}
    impl<S: State> State for SetUrl<S> {
        type Url = Set<members::url>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `url` field
        pub struct url(());
    }
}

/// Builder for constructing an instance of this type
pub struct WebsiteBuilder<'a, S: website_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (Option<WebsiteType<'a>>, Option<UriValue<'a>>),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> Website<'a> {
    /// Create a new builder for this type
    pub fn new() -> WebsiteBuilder<'a, website_state::Empty> {
        WebsiteBuilder::new()
    }
}

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

impl<'a, S: website_state::State> WebsiteBuilder<'a, S> {
    /// Set the `type` field (optional)
    pub fn r#type(mut self, value: impl Into<Option<WebsiteType<'a>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `type` field to an Option value (optional)
    pub fn maybe_type(mut self, value: Option<WebsiteType<'a>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S> WebsiteBuilder<'a, S>
where
    S: website_state::State,
    S::Url: website_state::IsUnset,
{
    /// Set the `url` field (required)
    pub fn url(
        mut self,
        value: impl Into<UriValue<'a>>,
    ) -> WebsiteBuilder<'a, website_state::SetUrl<S>> {
        self._fields.1 = Option::Some(value.into());
        WebsiteBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> WebsiteBuilder<'a, S>
where
    S: website_state::State,
    S::Url: website_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> Website<'a> {
        Website {
            r#type: self._fields.0,
            url: self._fields.1.unwrap(),
            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,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> Website<'a> {
        Website {
            r#type: self._fields.0,
            url: self._fields.1.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}