jacquard-api 0.12.0-beta.1

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

pub mod accept_convo;
pub mod add_reaction;
pub mod delete_message_for_self;
pub mod get_convo;
pub mod get_convo_availability;
pub mod get_convo_for_members;
pub mod get_log;
pub mod get_messages;
pub mod leave_convo;
pub mod list_convos;
pub mod mute_convo;
pub mod remove_reaction;
pub mod send_message;
pub mod send_message_batch;
pub mod unmute_convo;
pub mod update_all_read;
pub mod update_read;


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

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

#[allow(unused_imports)]
use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
use jacquard_common::deps::smol_str::SmolStr;
use jacquard_common::types::string::{Did, Datetime};
use jacquard_common::types::value::Data;
use jacquard_derive::{IntoStatic, open_union};
use jacquard_lexicon::lexicon::LexiconDoc;
use jacquard_lexicon::schema::LexiconSchema;

#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Serialize, Deserialize};
use crate::app_bsky::embed::record::Record;
use crate::app_bsky::embed::record::View;
use crate::app_bsky::richtext::facet::Facet;
use crate::chat_bsky::actor::ProfileViewBasic;
use crate::chat_bsky::convo;

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct ConvoView<S: BosStr = DefaultStr> {
    pub id: S,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_message: Option<ConvoViewLastMessage<S>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_reaction: Option<convo::MessageAndReactionView<S>>,
    pub members: Vec<ProfileViewBasic<S>>,
    pub muted: bool,
    pub rev: S,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<ConvoViewStatus<S>>,
    pub unread_count: i64,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum ConvoViewLastMessage<S: BosStr = DefaultStr> {
    #[serde(rename = "chat.bsky.convo.defs#messageView")]
    MessageView(Box<convo::MessageView<S>>),
    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
    DeletedMessageView(Box<convo::DeletedMessageView<S>>),
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ConvoViewStatus<S: BosStr = DefaultStr> {
    Request,
    Accepted,
    Other(S),
}

impl<S: BosStr> ConvoViewStatus<S> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Request => "request",
            Self::Accepted => "accepted",
            Self::Other(s) => s.as_ref(),
        }
    }
    /// Construct from a string-like value, matching known values.
    pub fn from_value(s: S) -> Self {
        match s.as_ref() {
            "request" => Self::Request,
            "accepted" => Self::Accepted,
            _ => Self::Other(s),
        }
    }
}

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

impl<S: BosStr> AsRef<str> for ConvoViewStatus<S> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

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

impl<'de, S: Deserialize<'de> + BosStr> Deserialize<'de> for ConvoViewStatus<S> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = S::deserialize(deserializer)?;
        Ok(Self::from_value(s))
    }
}

impl<S: BosStr + Default> Default for ConvoViewStatus<S> {
    fn default() -> Self {
        Self::Other(Default::default())
    }
}

impl<S: BosStr> jacquard_common::IntoStatic for ConvoViewStatus<S>
where
    S: BosStr + jacquard_common::IntoStatic,
    S::Output: BosStr,
{
    type Output = ConvoViewStatus<S::Output>;
    fn into_static(self) -> Self::Output {
        match self {
            ConvoViewStatus::Request => ConvoViewStatus::Request,
            ConvoViewStatus::Accepted => ConvoViewStatus::Accepted,
            ConvoViewStatus::Other(v) => ConvoViewStatus::Other(v.into_static()),
        }
    }
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct DeletedMessageView<S: BosStr = DefaultStr> {
    pub id: S,
    pub rev: S,
    pub sender: convo::MessageViewSender<S>,
    pub sent_at: Datetime,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogAcceptConvo<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogAddReaction<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub message: LogAddReactionMessage<S>,
    pub reaction: convo::ReactionView<S>,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum LogAddReactionMessage<S: BosStr = DefaultStr> {
    #[serde(rename = "chat.bsky.convo.defs#messageView")]
    MessageView(Box<convo::MessageView<S>>),
    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
    DeletedMessageView(Box<convo::DeletedMessageView<S>>),
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogBeginConvo<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogCreateMessage<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub message: LogCreateMessageMessage<S>,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum LogCreateMessageMessage<S: BosStr = DefaultStr> {
    #[serde(rename = "chat.bsky.convo.defs#messageView")]
    MessageView(Box<convo::MessageView<S>>),
    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
    DeletedMessageView(Box<convo::DeletedMessageView<S>>),
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogDeleteMessage<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub message: LogDeleteMessageMessage<S>,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum LogDeleteMessageMessage<S: BosStr = DefaultStr> {
    #[serde(rename = "chat.bsky.convo.defs#messageView")]
    MessageView(Box<convo::MessageView<S>>),
    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
    DeletedMessageView(Box<convo::DeletedMessageView<S>>),
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogLeaveConvo<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogMuteConvo<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogReadMessage<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub message: LogReadMessageMessage<S>,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum LogReadMessageMessage<S: BosStr = DefaultStr> {
    #[serde(rename = "chat.bsky.convo.defs#messageView")]
    MessageView(Box<convo::MessageView<S>>),
    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
    DeletedMessageView(Box<convo::DeletedMessageView<S>>),
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogRemoveReaction<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub message: LogRemoveReactionMessage<S>,
    pub reaction: convo::ReactionView<S>,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[open_union]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub enum LogRemoveReactionMessage<S: BosStr = DefaultStr> {
    #[serde(rename = "chat.bsky.convo.defs#messageView")]
    MessageView(Box<convo::MessageView<S>>),
    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
    DeletedMessageView(Box<convo::DeletedMessageView<S>>),
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct LogUnmuteConvo<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub rev: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct MessageAndReactionView<S: BosStr = DefaultStr> {
    pub message: convo::MessageView<S>,
    pub reaction: convo::ReactionView<S>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct MessageInput<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub embed: Option<Record<S>>,
    ///Annotations of text (mentions, URLs, hashtags, etc)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub facets: Option<Vec<Facet<S>>>,
    pub text: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct MessageRef<S: BosStr = DefaultStr> {
    pub convo_id: S,
    pub did: Did<S>,
    pub message_id: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct MessageView<S: BosStr = DefaultStr> {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub embed: Option<View<S>>,
    ///Annotations of text (mentions, URLs, hashtags, etc)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub facets: Option<Vec<Facet<S>>>,
    pub id: S,
    ///Reactions to this message, in ascending order of creation time.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reactions: Option<Vec<convo::ReactionView<S>>>,
    pub rev: S,
    pub sender: convo::MessageViewSender<S>,
    pub sent_at: Datetime,
    pub text: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct MessageViewSender<S: BosStr = DefaultStr> {
    pub did: Did<S>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct ReactionView<S: BosStr = DefaultStr> {
    pub created_at: Datetime,
    pub sender: convo::ReactionViewSender<S>,
    pub value: S,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}


#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
pub struct ReactionViewSender<S: BosStr = DefaultStr> {
    pub did: Did<S>,
    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
}

impl<S: BosStr> LexiconSchema for ConvoView<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "convoView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for DeletedMessageView<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "deletedMessageView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogAcceptConvo<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logAcceptConvo"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogAddReaction<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logAddReaction"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogBeginConvo<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logBeginConvo"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogCreateMessage<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logCreateMessage"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogDeleteMessage<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logDeleteMessage"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogLeaveConvo<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logLeaveConvo"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogMuteConvo<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logMuteConvo"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogReadMessage<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logReadMessage"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogRemoveReaction<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logRemoveReaction"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for LogUnmuteConvo<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "logUnmuteConvo"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for MessageAndReactionView<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "messageAndReactionView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for MessageInput<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "messageInput"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        {
            let value = &self.text;
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 10000usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("text"),
                    max: 10000usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        {
            let value = &self.text;
            {
                let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count();
                if count > 1000usize {
                    return Err(ConstraintError::MaxGraphemes {
                        path: ValidationPath::from_field("text"),
                        max: 1000usize,
                        actual: count,
                    });
                }
            }
        }
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for MessageRef<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "messageRef"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for MessageView<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "messageView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        {
            let value = &self.text;
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 10000usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("text"),
                    max: 10000usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        {
            let value = &self.text;
            {
                let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count();
                if count > 1000usize {
                    return Err(ConstraintError::MaxGraphemes {
                        path: ValidationPath::from_field("text"),
                        max: 1000usize,
                        actual: count,
                    });
                }
            }
        }
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for MessageViewSender<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "messageViewSender"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for ReactionView<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "reactionView"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

impl<S: BosStr> LexiconSchema for ReactionViewSender<S> {
    fn nsid() -> &'static str {
        "chat.bsky.convo.defs"
    }
    fn def_name() -> &'static str {
        "reactionViewSender"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_chat_bsky_convo_defs()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        Ok(())
    }
}

pub mod convo_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 Members;
        type Id;
        type Rev;
        type Muted;
        type UnreadCount;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Members = Unset;
        type Id = Unset;
        type Rev = Unset;
        type Muted = Unset;
        type UnreadCount = Unset;
    }
    ///State transition - sets the `members` field to Set
    pub struct SetMembers<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetMembers<St> {}
    impl<St: State> State for SetMembers<St> {
        type Members = Set<members::members>;
        type Id = St::Id;
        type Rev = St::Rev;
        type Muted = St::Muted;
        type UnreadCount = St::UnreadCount;
    }
    ///State transition - sets the `id` field to Set
    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetId<St> {}
    impl<St: State> State for SetId<St> {
        type Members = St::Members;
        type Id = Set<members::id>;
        type Rev = St::Rev;
        type Muted = St::Muted;
        type UnreadCount = St::UnreadCount;
    }
    ///State transition - sets the `rev` field to Set
    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetRev<St> {}
    impl<St: State> State for SetRev<St> {
        type Members = St::Members;
        type Id = St::Id;
        type Rev = Set<members::rev>;
        type Muted = St::Muted;
        type UnreadCount = St::UnreadCount;
    }
    ///State transition - sets the `muted` field to Set
    pub struct SetMuted<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetMuted<St> {}
    impl<St: State> State for SetMuted<St> {
        type Members = St::Members;
        type Id = St::Id;
        type Rev = St::Rev;
        type Muted = Set<members::muted>;
        type UnreadCount = St::UnreadCount;
    }
    ///State transition - sets the `unread_count` field to Set
    pub struct SetUnreadCount<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetUnreadCount<St> {}
    impl<St: State> State for SetUnreadCount<St> {
        type Members = St::Members;
        type Id = St::Id;
        type Rev = St::Rev;
        type Muted = St::Muted;
        type UnreadCount = Set<members::unread_count>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `members` field
        pub struct members(());
        ///Marker type for the `id` field
        pub struct id(());
        ///Marker type for the `rev` field
        pub struct rev(());
        ///Marker type for the `muted` field
        pub struct muted(());
        ///Marker type for the `unread_count` field
        pub struct unread_count(());
    }
}

/// Builder for constructing an instance of this type.
pub struct ConvoViewBuilder<S: BosStr, St: convo_view_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<S>,
        Option<ConvoViewLastMessage<S>>,
        Option<convo::MessageAndReactionView<S>>,
        Option<Vec<ProfileViewBasic<S>>>,
        Option<bool>,
        Option<S>,
        Option<ConvoViewStatus<S>>,
        Option<i64>,
    ),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> ConvoView<S> {
    /// Create a new builder for this type.
    pub fn new() -> ConvoViewBuilder<S, convo_view_state::Empty> {
        ConvoViewBuilder::new()
    }
}

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

impl<S: BosStr, St> ConvoViewBuilder<S, St>
where
    St: convo_view_state::State,
    St::Id: convo_view_state::IsUnset,
{
    /// Set the `id` field (required)
    pub fn id(
        mut self,
        value: impl Into<S>,
    ) -> ConvoViewBuilder<S, convo_view_state::SetId<St>> {
        self._fields.0 = Option::Some(value.into());
        ConvoViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St: convo_view_state::State> ConvoViewBuilder<S, St> {
    /// Set the `lastMessage` field (optional)
    pub fn last_message(
        mut self,
        value: impl Into<Option<ConvoViewLastMessage<S>>>,
    ) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `lastMessage` field to an Option value (optional)
    pub fn maybe_last_message(mut self, value: Option<ConvoViewLastMessage<S>>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<S: BosStr, St: convo_view_state::State> ConvoViewBuilder<S, St> {
    /// Set the `lastReaction` field (optional)
    pub fn last_reaction(
        mut self,
        value: impl Into<Option<convo::MessageAndReactionView<S>>>,
    ) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `lastReaction` field to an Option value (optional)
    pub fn maybe_last_reaction(
        mut self,
        value: Option<convo::MessageAndReactionView<S>>,
    ) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<S: BosStr, St> ConvoViewBuilder<S, St>
where
    St: convo_view_state::State,
    St::Members: convo_view_state::IsUnset,
{
    /// Set the `members` field (required)
    pub fn members(
        mut self,
        value: impl Into<Vec<ProfileViewBasic<S>>>,
    ) -> ConvoViewBuilder<S, convo_view_state::SetMembers<St>> {
        self._fields.3 = Option::Some(value.into());
        ConvoViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> ConvoViewBuilder<S, St>
where
    St: convo_view_state::State,
    St::Muted: convo_view_state::IsUnset,
{
    /// Set the `muted` field (required)
    pub fn muted(
        mut self,
        value: impl Into<bool>,
    ) -> ConvoViewBuilder<S, convo_view_state::SetMuted<St>> {
        self._fields.4 = Option::Some(value.into());
        ConvoViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> ConvoViewBuilder<S, St>
where
    St: convo_view_state::State,
    St::Rev: convo_view_state::IsUnset,
{
    /// Set the `rev` field (required)
    pub fn rev(
        mut self,
        value: impl Into<S>,
    ) -> ConvoViewBuilder<S, convo_view_state::SetRev<St>> {
        self._fields.5 = Option::Some(value.into());
        ConvoViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St: convo_view_state::State> ConvoViewBuilder<S, St> {
    /// Set the `status` field (optional)
    pub fn status(mut self, value: impl Into<Option<ConvoViewStatus<S>>>) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `status` field to an Option value (optional)
    pub fn maybe_status(mut self, value: Option<ConvoViewStatus<S>>) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<S: BosStr, St> ConvoViewBuilder<S, St>
where
    St: convo_view_state::State,
    St::UnreadCount: convo_view_state::IsUnset,
{
    /// Set the `unreadCount` field (required)
    pub fn unread_count(
        mut self,
        value: impl Into<i64>,
    ) -> ConvoViewBuilder<S, convo_view_state::SetUnreadCount<St>> {
        self._fields.7 = Option::Some(value.into());
        ConvoViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> ConvoViewBuilder<S, St>
where
    St: convo_view_state::State,
    St::Members: convo_view_state::IsSet,
    St::Id: convo_view_state::IsSet,
    St::Rev: convo_view_state::IsSet,
    St::Muted: convo_view_state::IsSet,
    St::UnreadCount: convo_view_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> ConvoView<S> {
        ConvoView {
            id: self._fields.0.unwrap(),
            last_message: self._fields.1,
            last_reaction: self._fields.2,
            members: self._fields.3.unwrap(),
            muted: self._fields.4.unwrap(),
            rev: self._fields.5.unwrap(),
            status: self._fields.6,
            unread_count: self._fields.7.unwrap(),
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data.
    pub fn build_with_data(
        self,
        extra_data: BTreeMap<SmolStr, Data<S>>,
    ) -> ConvoView<S> {
        ConvoView {
            id: self._fields.0.unwrap(),
            last_message: self._fields.1,
            last_reaction: self._fields.2,
            members: self._fields.3.unwrap(),
            muted: self._fields.4.unwrap(),
            rev: self._fields.5.unwrap(),
            status: self._fields.6,
            unread_count: self._fields.7.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

fn lexicon_doc_chat_bsky_convo_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("chat.bsky.convo.defs"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("convoView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("id"), SmolStr::new_static("rev"),
                            SmolStr::new_static("members"), SmolStr::new_static("muted"),
                            SmolStr::new_static("unreadCount")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("id"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("lastMessage"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("#messageView"),
                                    CowStr::new_static("#deletedMessageView")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("lastReaction"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![CowStr::new_static("#messageAndReactionView")],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("members"),
                            LexObjectProperty::Array(LexArray {
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "chat.bsky.actor.defs#profileViewBasic",
                                    ),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("muted"),
                            LexObjectProperty::Boolean(LexBoolean {
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("status"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("unreadCount"),
                            LexObjectProperty::Integer(LexInteger {
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("deletedMessageView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("id"), SmolStr::new_static("rev"),
                            SmolStr::new_static("sender"), SmolStr::new_static("sentAt")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("id"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("sender"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#messageViewSender"),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sentAt"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Datetime),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logAcceptConvo"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logAddReaction"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
                            SmolStr::new_static("message"),
                            SmolStr::new_static("reaction")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("message"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("#messageView"),
                                    CowStr::new_static("#deletedMessageView")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("reaction"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#reactionView"),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logBeginConvo"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logCreateMessage"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
                            SmolStr::new_static("message")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("message"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("#messageView"),
                                    CowStr::new_static("#deletedMessageView")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logDeleteMessage"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
                            SmolStr::new_static("message")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("message"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("#messageView"),
                                    CowStr::new_static("#deletedMessageView")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logLeaveConvo"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logMuteConvo"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logReadMessage"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
                            SmolStr::new_static("message")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("message"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("#messageView"),
                                    CowStr::new_static("#deletedMessageView")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logRemoveReaction"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
                            SmolStr::new_static("message"),
                            SmolStr::new_static("reaction")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("message"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("#messageView"),
                                    CowStr::new_static("#deletedMessageView")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("reaction"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#reactionView"),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("logUnmuteConvo"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("messageAndReactionView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("message"),
                            SmolStr::new_static("reaction")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("message"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#messageView"),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("reaction"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#reactionView"),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("messageInput"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("text")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("embed"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![CowStr::new_static("app.bsky.embed.record")],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("facets"),
                            LexObjectProperty::Array(LexArray {
                                description: Some(
                                    CowStr::new_static(
                                        "Annotations of text (mentions, URLs, hashtags, etc)",
                                    ),
                                ),
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static("app.bsky.richtext.facet"),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("text"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(10000usize),
                                max_graphemes: Some(1000usize),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("messageRef"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("did"), SmolStr::new_static("messageId"),
                            SmolStr::new_static("convoId")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("convoId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("did"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Did),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("messageId"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("messageView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("id"), SmolStr::new_static("rev"),
                            SmolStr::new_static("text"), SmolStr::new_static("sender"),
                            SmolStr::new_static("sentAt")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("embed"),
                            LexObjectProperty::Union(LexRefUnion {
                                refs: vec![
                                    CowStr::new_static("app.bsky.embed.record#view")
                                ],
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("facets"),
                            LexObjectProperty::Array(LexArray {
                                description: Some(
                                    CowStr::new_static(
                                        "Annotations of text (mentions, URLs, hashtags, etc)",
                                    ),
                                ),
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static("app.bsky.richtext.facet"),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("id"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("reactions"),
                            LexObjectProperty::Array(LexArray {
                                description: Some(
                                    CowStr::new_static(
                                        "Reactions to this message, in ascending order of creation time.",
                                    ),
                                ),
                                items: LexArrayItem::Ref(LexRef {
                                    r#ref: CowStr::new_static("#reactionView"),
                                    ..Default::default()
                                }),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("rev"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map.insert(
                            SmolStr::new_static("sender"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#messageViewSender"),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sentAt"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Datetime),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("text"),
                            LexObjectProperty::String(LexString {
                                max_length: Some(10000usize),
                                max_graphemes: Some(1000usize),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("messageViewSender"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("did")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("did"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Did),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("reactionView"),
                LexUserType::Object(LexObject {
                    required: Some(
                        vec![
                            SmolStr::new_static("value"), SmolStr::new_static("sender"),
                            SmolStr::new_static("createdAt")
                        ],
                    ),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("createdAt"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Datetime),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("sender"),
                            LexObjectProperty::Ref(LexRef {
                                r#ref: CowStr::new_static("#reactionViewSender"),
                                ..Default::default()
                            }),
                        );
                        map.insert(
                            SmolStr::new_static("value"),
                            LexObjectProperty::String(LexString { ..Default::default() }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map.insert(
                SmolStr::new_static("reactionViewSender"),
                LexUserType::Object(LexObject {
                    required: Some(vec![SmolStr::new_static("did")]),
                    properties: {
                        #[allow(unused_mut)]
                        let mut map = BTreeMap::new();
                        map.insert(
                            SmolStr::new_static("did"),
                            LexObjectProperty::String(LexString {
                                format: Some(LexStringFormat::Did),
                                ..Default::default()
                            }),
                        );
                        map
                    },
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}

pub mod deleted_message_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 Id;
        type Rev;
        type Sender;
        type SentAt;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Id = Unset;
        type Rev = Unset;
        type Sender = Unset;
        type SentAt = Unset;
    }
    ///State transition - sets the `id` field to Set
    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetId<St> {}
    impl<St: State> State for SetId<St> {
        type Id = Set<members::id>;
        type Rev = St::Rev;
        type Sender = St::Sender;
        type SentAt = St::SentAt;
    }
    ///State transition - sets the `rev` field to Set
    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetRev<St> {}
    impl<St: State> State for SetRev<St> {
        type Id = St::Id;
        type Rev = Set<members::rev>;
        type Sender = St::Sender;
        type SentAt = St::SentAt;
    }
    ///State transition - sets the `sender` field to Set
    pub struct SetSender<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetSender<St> {}
    impl<St: State> State for SetSender<St> {
        type Id = St::Id;
        type Rev = St::Rev;
        type Sender = Set<members::sender>;
        type SentAt = St::SentAt;
    }
    ///State transition - sets the `sent_at` field to Set
    pub struct SetSentAt<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetSentAt<St> {}
    impl<St: State> State for SetSentAt<St> {
        type Id = St::Id;
        type Rev = St::Rev;
        type Sender = St::Sender;
        type SentAt = Set<members::sent_at>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `id` field
        pub struct id(());
        ///Marker type for the `rev` field
        pub struct rev(());
        ///Marker type for the `sender` field
        pub struct sender(());
        ///Marker type for the `sent_at` field
        pub struct sent_at(());
    }
}

/// Builder for constructing an instance of this type.
pub struct DeletedMessageViewBuilder<S: BosStr, St: deleted_message_view_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<S>,
        Option<S>,
        Option<convo::MessageViewSender<S>>,
        Option<Datetime>,
    ),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> DeletedMessageView<S> {
    /// Create a new builder for this type.
    pub fn new() -> DeletedMessageViewBuilder<S, deleted_message_view_state::Empty> {
        DeletedMessageViewBuilder::new()
    }
}

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

impl<S: BosStr, St> DeletedMessageViewBuilder<S, St>
where
    St: deleted_message_view_state::State,
    St::Id: deleted_message_view_state::IsUnset,
{
    /// Set the `id` field (required)
    pub fn id(
        mut self,
        value: impl Into<S>,
    ) -> DeletedMessageViewBuilder<S, deleted_message_view_state::SetId<St>> {
        self._fields.0 = Option::Some(value.into());
        DeletedMessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> DeletedMessageViewBuilder<S, St>
where
    St: deleted_message_view_state::State,
    St::Rev: deleted_message_view_state::IsUnset,
{
    /// Set the `rev` field (required)
    pub fn rev(
        mut self,
        value: impl Into<S>,
    ) -> DeletedMessageViewBuilder<S, deleted_message_view_state::SetRev<St>> {
        self._fields.1 = Option::Some(value.into());
        DeletedMessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> DeletedMessageViewBuilder<S, St>
where
    St: deleted_message_view_state::State,
    St::Sender: deleted_message_view_state::IsUnset,
{
    /// Set the `sender` field (required)
    pub fn sender(
        mut self,
        value: impl Into<convo::MessageViewSender<S>>,
    ) -> DeletedMessageViewBuilder<S, deleted_message_view_state::SetSender<St>> {
        self._fields.2 = Option::Some(value.into());
        DeletedMessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> DeletedMessageViewBuilder<S, St>
where
    St: deleted_message_view_state::State,
    St::SentAt: deleted_message_view_state::IsUnset,
{
    /// Set the `sentAt` field (required)
    pub fn sent_at(
        mut self,
        value: impl Into<Datetime>,
    ) -> DeletedMessageViewBuilder<S, deleted_message_view_state::SetSentAt<St>> {
        self._fields.3 = Option::Some(value.into());
        DeletedMessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> DeletedMessageViewBuilder<S, St>
where
    St: deleted_message_view_state::State,
    St::Id: deleted_message_view_state::IsSet,
    St::Rev: deleted_message_view_state::IsSet,
    St::Sender: deleted_message_view_state::IsSet,
    St::SentAt: deleted_message_view_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> DeletedMessageView<S> {
        DeletedMessageView {
            id: self._fields.0.unwrap(),
            rev: self._fields.1.unwrap(),
            sender: self._fields.2.unwrap(),
            sent_at: 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<SmolStr, Data<S>>,
    ) -> DeletedMessageView<S> {
        DeletedMessageView {
            id: self._fields.0.unwrap(),
            rev: self._fields.1.unwrap(),
            sender: self._fields.2.unwrap(),
            sent_at: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod log_add_reaction_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 Message;
        type Reaction;
        type Rev;
        type ConvoId;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Message = Unset;
        type Reaction = Unset;
        type Rev = Unset;
        type ConvoId = Unset;
    }
    ///State transition - sets the `message` field to Set
    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetMessage<St> {}
    impl<St: State> State for SetMessage<St> {
        type Message = Set<members::message>;
        type Reaction = St::Reaction;
        type Rev = St::Rev;
        type ConvoId = St::ConvoId;
    }
    ///State transition - sets the `reaction` field to Set
    pub struct SetReaction<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetReaction<St> {}
    impl<St: State> State for SetReaction<St> {
        type Message = St::Message;
        type Reaction = Set<members::reaction>;
        type Rev = St::Rev;
        type ConvoId = St::ConvoId;
    }
    ///State transition - sets the `rev` field to Set
    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetRev<St> {}
    impl<St: State> State for SetRev<St> {
        type Message = St::Message;
        type Reaction = St::Reaction;
        type Rev = Set<members::rev>;
        type ConvoId = St::ConvoId;
    }
    ///State transition - sets the `convo_id` field to Set
    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetConvoId<St> {}
    impl<St: State> State for SetConvoId<St> {
        type Message = St::Message;
        type Reaction = St::Reaction;
        type Rev = St::Rev;
        type ConvoId = Set<members::convo_id>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `message` field
        pub struct message(());
        ///Marker type for the `reaction` field
        pub struct reaction(());
        ///Marker type for the `rev` field
        pub struct rev(());
        ///Marker type for the `convo_id` field
        pub struct convo_id(());
    }
}

/// Builder for constructing an instance of this type.
pub struct LogAddReactionBuilder<S: BosStr, St: log_add_reaction_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<S>,
        Option<LogAddReactionMessage<S>>,
        Option<convo::ReactionView<S>>,
        Option<S>,
    ),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> LogAddReaction<S> {
    /// Create a new builder for this type.
    pub fn new() -> LogAddReactionBuilder<S, log_add_reaction_state::Empty> {
        LogAddReactionBuilder::new()
    }
}

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

impl<S: BosStr, St> LogAddReactionBuilder<S, St>
where
    St: log_add_reaction_state::State,
    St::ConvoId: log_add_reaction_state::IsUnset,
{
    /// Set the `convoId` field (required)
    pub fn convo_id(
        mut self,
        value: impl Into<S>,
    ) -> LogAddReactionBuilder<S, log_add_reaction_state::SetConvoId<St>> {
        self._fields.0 = Option::Some(value.into());
        LogAddReactionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogAddReactionBuilder<S, St>
where
    St: log_add_reaction_state::State,
    St::Message: log_add_reaction_state::IsUnset,
{
    /// Set the `message` field (required)
    pub fn message(
        mut self,
        value: impl Into<LogAddReactionMessage<S>>,
    ) -> LogAddReactionBuilder<S, log_add_reaction_state::SetMessage<St>> {
        self._fields.1 = Option::Some(value.into());
        LogAddReactionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogAddReactionBuilder<S, St>
where
    St: log_add_reaction_state::State,
    St::Reaction: log_add_reaction_state::IsUnset,
{
    /// Set the `reaction` field (required)
    pub fn reaction(
        mut self,
        value: impl Into<convo::ReactionView<S>>,
    ) -> LogAddReactionBuilder<S, log_add_reaction_state::SetReaction<St>> {
        self._fields.2 = Option::Some(value.into());
        LogAddReactionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogAddReactionBuilder<S, St>
where
    St: log_add_reaction_state::State,
    St::Rev: log_add_reaction_state::IsUnset,
{
    /// Set the `rev` field (required)
    pub fn rev(
        mut self,
        value: impl Into<S>,
    ) -> LogAddReactionBuilder<S, log_add_reaction_state::SetRev<St>> {
        self._fields.3 = Option::Some(value.into());
        LogAddReactionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogAddReactionBuilder<S, St>
where
    St: log_add_reaction_state::State,
    St::Message: log_add_reaction_state::IsSet,
    St::Reaction: log_add_reaction_state::IsSet,
    St::Rev: log_add_reaction_state::IsSet,
    St::ConvoId: log_add_reaction_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> LogAddReaction<S> {
        LogAddReaction {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            reaction: self._fields.2.unwrap(),
            rev: 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<SmolStr, Data<S>>,
    ) -> LogAddReaction<S> {
        LogAddReaction {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            reaction: self._fields.2.unwrap(),
            rev: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod log_create_message_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 Message;
        type ConvoId;
        type Rev;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Message = Unset;
        type ConvoId = Unset;
        type Rev = Unset;
    }
    ///State transition - sets the `message` field to Set
    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetMessage<St> {}
    impl<St: State> State for SetMessage<St> {
        type Message = Set<members::message>;
        type ConvoId = St::ConvoId;
        type Rev = St::Rev;
    }
    ///State transition - sets the `convo_id` field to Set
    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetConvoId<St> {}
    impl<St: State> State for SetConvoId<St> {
        type Message = St::Message;
        type ConvoId = Set<members::convo_id>;
        type Rev = St::Rev;
    }
    ///State transition - sets the `rev` field to Set
    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetRev<St> {}
    impl<St: State> State for SetRev<St> {
        type Message = St::Message;
        type ConvoId = St::ConvoId;
        type Rev = Set<members::rev>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `message` field
        pub struct message(());
        ///Marker type for the `convo_id` field
        pub struct convo_id(());
        ///Marker type for the `rev` field
        pub struct rev(());
    }
}

/// Builder for constructing an instance of this type.
pub struct LogCreateMessageBuilder<S: BosStr, St: log_create_message_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<S>, Option<LogCreateMessageMessage<S>>, Option<S>),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> LogCreateMessage<S> {
    /// Create a new builder for this type.
    pub fn new() -> LogCreateMessageBuilder<S, log_create_message_state::Empty> {
        LogCreateMessageBuilder::new()
    }
}

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

impl<S: BosStr, St> LogCreateMessageBuilder<S, St>
where
    St: log_create_message_state::State,
    St::ConvoId: log_create_message_state::IsUnset,
{
    /// Set the `convoId` field (required)
    pub fn convo_id(
        mut self,
        value: impl Into<S>,
    ) -> LogCreateMessageBuilder<S, log_create_message_state::SetConvoId<St>> {
        self._fields.0 = Option::Some(value.into());
        LogCreateMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogCreateMessageBuilder<S, St>
where
    St: log_create_message_state::State,
    St::Message: log_create_message_state::IsUnset,
{
    /// Set the `message` field (required)
    pub fn message(
        mut self,
        value: impl Into<LogCreateMessageMessage<S>>,
    ) -> LogCreateMessageBuilder<S, log_create_message_state::SetMessage<St>> {
        self._fields.1 = Option::Some(value.into());
        LogCreateMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogCreateMessageBuilder<S, St>
where
    St: log_create_message_state::State,
    St::Rev: log_create_message_state::IsUnset,
{
    /// Set the `rev` field (required)
    pub fn rev(
        mut self,
        value: impl Into<S>,
    ) -> LogCreateMessageBuilder<S, log_create_message_state::SetRev<St>> {
        self._fields.2 = Option::Some(value.into());
        LogCreateMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogCreateMessageBuilder<S, St>
where
    St: log_create_message_state::State,
    St::Message: log_create_message_state::IsSet,
    St::ConvoId: log_create_message_state::IsSet,
    St::Rev: log_create_message_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> LogCreateMessage<S> {
        LogCreateMessage {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            rev: 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<SmolStr, Data<S>>,
    ) -> LogCreateMessage<S> {
        LogCreateMessage {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            rev: self._fields.2.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod log_delete_message_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 ConvoId;
        type Message;
        type Rev;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type ConvoId = Unset;
        type Message = Unset;
        type Rev = Unset;
    }
    ///State transition - sets the `convo_id` field to Set
    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetConvoId<St> {}
    impl<St: State> State for SetConvoId<St> {
        type ConvoId = Set<members::convo_id>;
        type Message = St::Message;
        type Rev = St::Rev;
    }
    ///State transition - sets the `message` field to Set
    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetMessage<St> {}
    impl<St: State> State for SetMessage<St> {
        type ConvoId = St::ConvoId;
        type Message = Set<members::message>;
        type Rev = St::Rev;
    }
    ///State transition - sets the `rev` field to Set
    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetRev<St> {}
    impl<St: State> State for SetRev<St> {
        type ConvoId = St::ConvoId;
        type Message = St::Message;
        type Rev = Set<members::rev>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `convo_id` field
        pub struct convo_id(());
        ///Marker type for the `message` field
        pub struct message(());
        ///Marker type for the `rev` field
        pub struct rev(());
    }
}

/// Builder for constructing an instance of this type.
pub struct LogDeleteMessageBuilder<S: BosStr, St: log_delete_message_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<S>, Option<LogDeleteMessageMessage<S>>, Option<S>),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> LogDeleteMessage<S> {
    /// Create a new builder for this type.
    pub fn new() -> LogDeleteMessageBuilder<S, log_delete_message_state::Empty> {
        LogDeleteMessageBuilder::new()
    }
}

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

impl<S: BosStr, St> LogDeleteMessageBuilder<S, St>
where
    St: log_delete_message_state::State,
    St::ConvoId: log_delete_message_state::IsUnset,
{
    /// Set the `convoId` field (required)
    pub fn convo_id(
        mut self,
        value: impl Into<S>,
    ) -> LogDeleteMessageBuilder<S, log_delete_message_state::SetConvoId<St>> {
        self._fields.0 = Option::Some(value.into());
        LogDeleteMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogDeleteMessageBuilder<S, St>
where
    St: log_delete_message_state::State,
    St::Message: log_delete_message_state::IsUnset,
{
    /// Set the `message` field (required)
    pub fn message(
        mut self,
        value: impl Into<LogDeleteMessageMessage<S>>,
    ) -> LogDeleteMessageBuilder<S, log_delete_message_state::SetMessage<St>> {
        self._fields.1 = Option::Some(value.into());
        LogDeleteMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogDeleteMessageBuilder<S, St>
where
    St: log_delete_message_state::State,
    St::Rev: log_delete_message_state::IsUnset,
{
    /// Set the `rev` field (required)
    pub fn rev(
        mut self,
        value: impl Into<S>,
    ) -> LogDeleteMessageBuilder<S, log_delete_message_state::SetRev<St>> {
        self._fields.2 = Option::Some(value.into());
        LogDeleteMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogDeleteMessageBuilder<S, St>
where
    St: log_delete_message_state::State,
    St::ConvoId: log_delete_message_state::IsSet,
    St::Message: log_delete_message_state::IsSet,
    St::Rev: log_delete_message_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> LogDeleteMessage<S> {
        LogDeleteMessage {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            rev: 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<SmolStr, Data<S>>,
    ) -> LogDeleteMessage<S> {
        LogDeleteMessage {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            rev: self._fields.2.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod log_read_message_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 Rev;
        type ConvoId;
        type Message;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Rev = Unset;
        type ConvoId = Unset;
        type Message = Unset;
    }
    ///State transition - sets the `rev` field to Set
    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetRev<St> {}
    impl<St: State> State for SetRev<St> {
        type Rev = Set<members::rev>;
        type ConvoId = St::ConvoId;
        type Message = St::Message;
    }
    ///State transition - sets the `convo_id` field to Set
    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetConvoId<St> {}
    impl<St: State> State for SetConvoId<St> {
        type Rev = St::Rev;
        type ConvoId = Set<members::convo_id>;
        type Message = St::Message;
    }
    ///State transition - sets the `message` field to Set
    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetMessage<St> {}
    impl<St: State> State for SetMessage<St> {
        type Rev = St::Rev;
        type ConvoId = St::ConvoId;
        type Message = Set<members::message>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `rev` field
        pub struct rev(());
        ///Marker type for the `convo_id` field
        pub struct convo_id(());
        ///Marker type for the `message` field
        pub struct message(());
    }
}

/// Builder for constructing an instance of this type.
pub struct LogReadMessageBuilder<S: BosStr, St: log_read_message_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<S>, Option<LogReadMessageMessage<S>>, Option<S>),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> LogReadMessage<S> {
    /// Create a new builder for this type.
    pub fn new() -> LogReadMessageBuilder<S, log_read_message_state::Empty> {
        LogReadMessageBuilder::new()
    }
}

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

impl<S: BosStr, St> LogReadMessageBuilder<S, St>
where
    St: log_read_message_state::State,
    St::ConvoId: log_read_message_state::IsUnset,
{
    /// Set the `convoId` field (required)
    pub fn convo_id(
        mut self,
        value: impl Into<S>,
    ) -> LogReadMessageBuilder<S, log_read_message_state::SetConvoId<St>> {
        self._fields.0 = Option::Some(value.into());
        LogReadMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogReadMessageBuilder<S, St>
where
    St: log_read_message_state::State,
    St::Message: log_read_message_state::IsUnset,
{
    /// Set the `message` field (required)
    pub fn message(
        mut self,
        value: impl Into<LogReadMessageMessage<S>>,
    ) -> LogReadMessageBuilder<S, log_read_message_state::SetMessage<St>> {
        self._fields.1 = Option::Some(value.into());
        LogReadMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogReadMessageBuilder<S, St>
where
    St: log_read_message_state::State,
    St::Rev: log_read_message_state::IsUnset,
{
    /// Set the `rev` field (required)
    pub fn rev(
        mut self,
        value: impl Into<S>,
    ) -> LogReadMessageBuilder<S, log_read_message_state::SetRev<St>> {
        self._fields.2 = Option::Some(value.into());
        LogReadMessageBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogReadMessageBuilder<S, St>
where
    St: log_read_message_state::State,
    St::Rev: log_read_message_state::IsSet,
    St::ConvoId: log_read_message_state::IsSet,
    St::Message: log_read_message_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> LogReadMessage<S> {
        LogReadMessage {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            rev: 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<SmolStr, Data<S>>,
    ) -> LogReadMessage<S> {
        LogReadMessage {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            rev: self._fields.2.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod log_remove_reaction_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 Rev;
        type Message;
        type ConvoId;
        type Reaction;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Rev = Unset;
        type Message = Unset;
        type ConvoId = Unset;
        type Reaction = Unset;
    }
    ///State transition - sets the `rev` field to Set
    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetRev<St> {}
    impl<St: State> State for SetRev<St> {
        type Rev = Set<members::rev>;
        type Message = St::Message;
        type ConvoId = St::ConvoId;
        type Reaction = St::Reaction;
    }
    ///State transition - sets the `message` field to Set
    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetMessage<St> {}
    impl<St: State> State for SetMessage<St> {
        type Rev = St::Rev;
        type Message = Set<members::message>;
        type ConvoId = St::ConvoId;
        type Reaction = St::Reaction;
    }
    ///State transition - sets the `convo_id` field to Set
    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetConvoId<St> {}
    impl<St: State> State for SetConvoId<St> {
        type Rev = St::Rev;
        type Message = St::Message;
        type ConvoId = Set<members::convo_id>;
        type Reaction = St::Reaction;
    }
    ///State transition - sets the `reaction` field to Set
    pub struct SetReaction<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetReaction<St> {}
    impl<St: State> State for SetReaction<St> {
        type Rev = St::Rev;
        type Message = St::Message;
        type ConvoId = St::ConvoId;
        type Reaction = Set<members::reaction>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `rev` field
        pub struct rev(());
        ///Marker type for the `message` field
        pub struct message(());
        ///Marker type for the `convo_id` field
        pub struct convo_id(());
        ///Marker type for the `reaction` field
        pub struct reaction(());
    }
}

/// Builder for constructing an instance of this type.
pub struct LogRemoveReactionBuilder<S: BosStr, St: log_remove_reaction_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<S>,
        Option<LogRemoveReactionMessage<S>>,
        Option<convo::ReactionView<S>>,
        Option<S>,
    ),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> LogRemoveReaction<S> {
    /// Create a new builder for this type.
    pub fn new() -> LogRemoveReactionBuilder<S, log_remove_reaction_state::Empty> {
        LogRemoveReactionBuilder::new()
    }
}

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

impl<S: BosStr, St> LogRemoveReactionBuilder<S, St>
where
    St: log_remove_reaction_state::State,
    St::ConvoId: log_remove_reaction_state::IsUnset,
{
    /// Set the `convoId` field (required)
    pub fn convo_id(
        mut self,
        value: impl Into<S>,
    ) -> LogRemoveReactionBuilder<S, log_remove_reaction_state::SetConvoId<St>> {
        self._fields.0 = Option::Some(value.into());
        LogRemoveReactionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogRemoveReactionBuilder<S, St>
where
    St: log_remove_reaction_state::State,
    St::Message: log_remove_reaction_state::IsUnset,
{
    /// Set the `message` field (required)
    pub fn message(
        mut self,
        value: impl Into<LogRemoveReactionMessage<S>>,
    ) -> LogRemoveReactionBuilder<S, log_remove_reaction_state::SetMessage<St>> {
        self._fields.1 = Option::Some(value.into());
        LogRemoveReactionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogRemoveReactionBuilder<S, St>
where
    St: log_remove_reaction_state::State,
    St::Reaction: log_remove_reaction_state::IsUnset,
{
    /// Set the `reaction` field (required)
    pub fn reaction(
        mut self,
        value: impl Into<convo::ReactionView<S>>,
    ) -> LogRemoveReactionBuilder<S, log_remove_reaction_state::SetReaction<St>> {
        self._fields.2 = Option::Some(value.into());
        LogRemoveReactionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogRemoveReactionBuilder<S, St>
where
    St: log_remove_reaction_state::State,
    St::Rev: log_remove_reaction_state::IsUnset,
{
    /// Set the `rev` field (required)
    pub fn rev(
        mut self,
        value: impl Into<S>,
    ) -> LogRemoveReactionBuilder<S, log_remove_reaction_state::SetRev<St>> {
        self._fields.3 = Option::Some(value.into());
        LogRemoveReactionBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> LogRemoveReactionBuilder<S, St>
where
    St: log_remove_reaction_state::State,
    St::Rev: log_remove_reaction_state::IsSet,
    St::Message: log_remove_reaction_state::IsSet,
    St::ConvoId: log_remove_reaction_state::IsSet,
    St::Reaction: log_remove_reaction_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> LogRemoveReaction<S> {
        LogRemoveReaction {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            reaction: self._fields.2.unwrap(),
            rev: 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<SmolStr, Data<S>>,
    ) -> LogRemoveReaction<S> {
        LogRemoveReaction {
            convo_id: self._fields.0.unwrap(),
            message: self._fields.1.unwrap(),
            reaction: self._fields.2.unwrap(),
            rev: self._fields.3.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod message_and_reaction_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 Message;
        type Reaction;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Message = Unset;
        type Reaction = Unset;
    }
    ///State transition - sets the `message` field to Set
    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetMessage<St> {}
    impl<St: State> State for SetMessage<St> {
        type Message = Set<members::message>;
        type Reaction = St::Reaction;
    }
    ///State transition - sets the `reaction` field to Set
    pub struct SetReaction<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetReaction<St> {}
    impl<St: State> State for SetReaction<St> {
        type Message = St::Message;
        type Reaction = Set<members::reaction>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `message` field
        pub struct message(());
        ///Marker type for the `reaction` field
        pub struct reaction(());
    }
}

/// Builder for constructing an instance of this type.
pub struct MessageAndReactionViewBuilder<
    S: BosStr,
    St: message_and_reaction_view_state::State,
> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<convo::MessageView<S>>, Option<convo::ReactionView<S>>),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> MessageAndReactionView<S> {
    /// Create a new builder for this type.
    pub fn new() -> MessageAndReactionViewBuilder<
        S,
        message_and_reaction_view_state::Empty,
    > {
        MessageAndReactionViewBuilder::new()
    }
}

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

impl<S: BosStr, St> MessageAndReactionViewBuilder<S, St>
where
    St: message_and_reaction_view_state::State,
    St::Message: message_and_reaction_view_state::IsUnset,
{
    /// Set the `message` field (required)
    pub fn message(
        mut self,
        value: impl Into<convo::MessageView<S>>,
    ) -> MessageAndReactionViewBuilder<
        S,
        message_and_reaction_view_state::SetMessage<St>,
    > {
        self._fields.0 = Option::Some(value.into());
        MessageAndReactionViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageAndReactionViewBuilder<S, St>
where
    St: message_and_reaction_view_state::State,
    St::Reaction: message_and_reaction_view_state::IsUnset,
{
    /// Set the `reaction` field (required)
    pub fn reaction(
        mut self,
        value: impl Into<convo::ReactionView<S>>,
    ) -> MessageAndReactionViewBuilder<
        S,
        message_and_reaction_view_state::SetReaction<St>,
    > {
        self._fields.1 = Option::Some(value.into());
        MessageAndReactionViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageAndReactionViewBuilder<S, St>
where
    St: message_and_reaction_view_state::State,
    St::Message: message_and_reaction_view_state::IsSet,
    St::Reaction: message_and_reaction_view_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> MessageAndReactionView<S> {
        MessageAndReactionView {
            message: self._fields.0.unwrap(),
            reaction: 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<SmolStr, Data<S>>,
    ) -> MessageAndReactionView<S> {
        MessageAndReactionView {
            message: self._fields.0.unwrap(),
            reaction: self._fields.1.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

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

/// Builder for constructing an instance of this type.
pub struct MessageRefBuilder<S: BosStr, St: message_ref_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<S>, Option<Did<S>>, Option<S>),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> MessageRef<S> {
    /// Create a new builder for this type.
    pub fn new() -> MessageRefBuilder<S, message_ref_state::Empty> {
        MessageRefBuilder::new()
    }
}

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

impl<S: BosStr, St> MessageRefBuilder<S, St>
where
    St: message_ref_state::State,
    St::ConvoId: message_ref_state::IsUnset,
{
    /// Set the `convoId` field (required)
    pub fn convo_id(
        mut self,
        value: impl Into<S>,
    ) -> MessageRefBuilder<S, message_ref_state::SetConvoId<St>> {
        self._fields.0 = Option::Some(value.into());
        MessageRefBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageRefBuilder<S, St>
where
    St: message_ref_state::State,
    St::Did: message_ref_state::IsUnset,
{
    /// Set the `did` field (required)
    pub fn did(
        mut self,
        value: impl Into<Did<S>>,
    ) -> MessageRefBuilder<S, message_ref_state::SetDid<St>> {
        self._fields.1 = Option::Some(value.into());
        MessageRefBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageRefBuilder<S, St>
where
    St: message_ref_state::State,
    St::MessageId: message_ref_state::IsUnset,
{
    /// Set the `messageId` field (required)
    pub fn message_id(
        mut self,
        value: impl Into<S>,
    ) -> MessageRefBuilder<S, message_ref_state::SetMessageId<St>> {
        self._fields.2 = Option::Some(value.into());
        MessageRefBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageRefBuilder<S, St>
where
    St: message_ref_state::State,
    St::MessageId: message_ref_state::IsSet,
    St::ConvoId: message_ref_state::IsSet,
    St::Did: message_ref_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> MessageRef<S> {
        MessageRef {
            convo_id: self._fields.0.unwrap(),
            did: self._fields.1.unwrap(),
            message_id: 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<SmolStr, Data<S>>,
    ) -> MessageRef<S> {
        MessageRef {
            convo_id: self._fields.0.unwrap(),
            did: self._fields.1.unwrap(),
            message_id: self._fields.2.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod message_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 Rev;
        type Text;
        type SentAt;
        type Sender;
        type Id;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Rev = Unset;
        type Text = Unset;
        type SentAt = Unset;
        type Sender = Unset;
        type Id = Unset;
    }
    ///State transition - sets the `rev` field to Set
    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetRev<St> {}
    impl<St: State> State for SetRev<St> {
        type Rev = Set<members::rev>;
        type Text = St::Text;
        type SentAt = St::SentAt;
        type Sender = St::Sender;
        type Id = St::Id;
    }
    ///State transition - sets the `text` field to Set
    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetText<St> {}
    impl<St: State> State for SetText<St> {
        type Rev = St::Rev;
        type Text = Set<members::text>;
        type SentAt = St::SentAt;
        type Sender = St::Sender;
        type Id = St::Id;
    }
    ///State transition - sets the `sent_at` field to Set
    pub struct SetSentAt<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetSentAt<St> {}
    impl<St: State> State for SetSentAt<St> {
        type Rev = St::Rev;
        type Text = St::Text;
        type SentAt = Set<members::sent_at>;
        type Sender = St::Sender;
        type Id = St::Id;
    }
    ///State transition - sets the `sender` field to Set
    pub struct SetSender<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetSender<St> {}
    impl<St: State> State for SetSender<St> {
        type Rev = St::Rev;
        type Text = St::Text;
        type SentAt = St::SentAt;
        type Sender = Set<members::sender>;
        type Id = St::Id;
    }
    ///State transition - sets the `id` field to Set
    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetId<St> {}
    impl<St: State> State for SetId<St> {
        type Rev = St::Rev;
        type Text = St::Text;
        type SentAt = St::SentAt;
        type Sender = St::Sender;
        type Id = Set<members::id>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `rev` field
        pub struct rev(());
        ///Marker type for the `text` field
        pub struct text(());
        ///Marker type for the `sent_at` field
        pub struct sent_at(());
        ///Marker type for the `sender` field
        pub struct sender(());
        ///Marker type for the `id` field
        pub struct id(());
    }
}

/// Builder for constructing an instance of this type.
pub struct MessageViewBuilder<S: BosStr, St: message_view_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (
        Option<View<S>>,
        Option<Vec<Facet<S>>>,
        Option<S>,
        Option<Vec<convo::ReactionView<S>>>,
        Option<S>,
        Option<convo::MessageViewSender<S>>,
        Option<Datetime>,
        Option<S>,
    ),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> MessageView<S> {
    /// Create a new builder for this type.
    pub fn new() -> MessageViewBuilder<S, message_view_state::Empty> {
        MessageViewBuilder::new()
    }
}

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

impl<S: BosStr, St: message_view_state::State> MessageViewBuilder<S, St> {
    /// Set the `embed` field (optional)
    pub fn embed(mut self, value: impl Into<Option<View<S>>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `embed` field to an Option value (optional)
    pub fn maybe_embed(mut self, value: Option<View<S>>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<S: BosStr, St: message_view_state::State> MessageViewBuilder<S, St> {
    /// Set the `facets` field (optional)
    pub fn facets(mut self, value: impl Into<Option<Vec<Facet<S>>>>) -> Self {
        self._fields.1 = value.into();
        self
    }
    /// Set the `facets` field to an Option value (optional)
    pub fn maybe_facets(mut self, value: Option<Vec<Facet<S>>>) -> Self {
        self._fields.1 = value;
        self
    }
}

impl<S: BosStr, St> MessageViewBuilder<S, St>
where
    St: message_view_state::State,
    St::Id: message_view_state::IsUnset,
{
    /// Set the `id` field (required)
    pub fn id(
        mut self,
        value: impl Into<S>,
    ) -> MessageViewBuilder<S, message_view_state::SetId<St>> {
        self._fields.2 = Option::Some(value.into());
        MessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St: message_view_state::State> MessageViewBuilder<S, St> {
    /// Set the `reactions` field (optional)
    pub fn reactions(
        mut self,
        value: impl Into<Option<Vec<convo::ReactionView<S>>>>,
    ) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `reactions` field to an Option value (optional)
    pub fn maybe_reactions(
        mut self,
        value: Option<Vec<convo::ReactionView<S>>>,
    ) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<S: BosStr, St> MessageViewBuilder<S, St>
where
    St: message_view_state::State,
    St::Rev: message_view_state::IsUnset,
{
    /// Set the `rev` field (required)
    pub fn rev(
        mut self,
        value: impl Into<S>,
    ) -> MessageViewBuilder<S, message_view_state::SetRev<St>> {
        self._fields.4 = Option::Some(value.into());
        MessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageViewBuilder<S, St>
where
    St: message_view_state::State,
    St::Sender: message_view_state::IsUnset,
{
    /// Set the `sender` field (required)
    pub fn sender(
        mut self,
        value: impl Into<convo::MessageViewSender<S>>,
    ) -> MessageViewBuilder<S, message_view_state::SetSender<St>> {
        self._fields.5 = Option::Some(value.into());
        MessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageViewBuilder<S, St>
where
    St: message_view_state::State,
    St::SentAt: message_view_state::IsUnset,
{
    /// Set the `sentAt` field (required)
    pub fn sent_at(
        mut self,
        value: impl Into<Datetime>,
    ) -> MessageViewBuilder<S, message_view_state::SetSentAt<St>> {
        self._fields.6 = Option::Some(value.into());
        MessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageViewBuilder<S, St>
where
    St: message_view_state::State,
    St::Text: message_view_state::IsUnset,
{
    /// Set the `text` field (required)
    pub fn text(
        mut self,
        value: impl Into<S>,
    ) -> MessageViewBuilder<S, message_view_state::SetText<St>> {
        self._fields.7 = Option::Some(value.into());
        MessageViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageViewBuilder<S, St>
where
    St: message_view_state::State,
    St::Rev: message_view_state::IsSet,
    St::Text: message_view_state::IsSet,
    St::SentAt: message_view_state::IsSet,
    St::Sender: message_view_state::IsSet,
    St::Id: message_view_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> MessageView<S> {
        MessageView {
            embed: self._fields.0,
            facets: self._fields.1,
            id: self._fields.2.unwrap(),
            reactions: self._fields.3,
            rev: self._fields.4.unwrap(),
            sender: self._fields.5.unwrap(),
            sent_at: self._fields.6.unwrap(),
            text: self._fields.7.unwrap(),
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data.
    pub fn build_with_data(
        self,
        extra_data: BTreeMap<SmolStr, Data<S>>,
    ) -> MessageView<S> {
        MessageView {
            embed: self._fields.0,
            facets: self._fields.1,
            id: self._fields.2.unwrap(),
            reactions: self._fields.3,
            rev: self._fields.4.unwrap(),
            sender: self._fields.5.unwrap(),
            sent_at: self._fields.6.unwrap(),
            text: self._fields.7.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

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

/// Builder for constructing an instance of this type.
pub struct MessageViewSenderBuilder<S: BosStr, St: message_view_sender_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<Did<S>>,),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> MessageViewSender<S> {
    /// Create a new builder for this type.
    pub fn new() -> MessageViewSenderBuilder<S, message_view_sender_state::Empty> {
        MessageViewSenderBuilder::new()
    }
}

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

impl<S: BosStr, St> MessageViewSenderBuilder<S, St>
where
    St: message_view_sender_state::State,
    St::Did: message_view_sender_state::IsUnset,
{
    /// Set the `did` field (required)
    pub fn did(
        mut self,
        value: impl Into<Did<S>>,
    ) -> MessageViewSenderBuilder<S, message_view_sender_state::SetDid<St>> {
        self._fields.0 = Option::Some(value.into());
        MessageViewSenderBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> MessageViewSenderBuilder<S, St>
where
    St: message_view_sender_state::State,
    St::Did: message_view_sender_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> MessageViewSender<S> {
        MessageViewSender {
            did: self._fields.0.unwrap(),
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data.
    pub fn build_with_data(
        self,
        extra_data: BTreeMap<SmolStr, Data<S>>,
    ) -> MessageViewSender<S> {
        MessageViewSender {
            did: self._fields.0.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

pub mod reaction_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 Value;
        type Sender;
        type CreatedAt;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type Value = Unset;
        type Sender = Unset;
        type CreatedAt = Unset;
    }
    ///State transition - sets the `value` field to Set
    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetValue<St> {}
    impl<St: State> State for SetValue<St> {
        type Value = Set<members::value>;
        type Sender = St::Sender;
        type CreatedAt = St::CreatedAt;
    }
    ///State transition - sets the `sender` field to Set
    pub struct SetSender<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetSender<St> {}
    impl<St: State> State for SetSender<St> {
        type Value = St::Value;
        type Sender = Set<members::sender>;
        type CreatedAt = St::CreatedAt;
    }
    ///State transition - sets the `created_at` field to Set
    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
    impl<St: State> State for SetCreatedAt<St> {
        type Value = St::Value;
        type Sender = St::Sender;
        type CreatedAt = Set<members::created_at>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `value` field
        pub struct value(());
        ///Marker type for the `sender` field
        pub struct sender(());
        ///Marker type for the `created_at` field
        pub struct created_at(());
    }
}

/// Builder for constructing an instance of this type.
pub struct ReactionViewBuilder<S: BosStr, St: reaction_view_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<Datetime>, Option<convo::ReactionViewSender<S>>, Option<S>),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> ReactionView<S> {
    /// Create a new builder for this type.
    pub fn new() -> ReactionViewBuilder<S, reaction_view_state::Empty> {
        ReactionViewBuilder::new()
    }
}

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

impl<S: BosStr, St> ReactionViewBuilder<S, St>
where
    St: reaction_view_state::State,
    St::CreatedAt: reaction_view_state::IsUnset,
{
    /// Set the `createdAt` field (required)
    pub fn created_at(
        mut self,
        value: impl Into<Datetime>,
    ) -> ReactionViewBuilder<S, reaction_view_state::SetCreatedAt<St>> {
        self._fields.0 = Option::Some(value.into());
        ReactionViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> ReactionViewBuilder<S, St>
where
    St: reaction_view_state::State,
    St::Sender: reaction_view_state::IsUnset,
{
    /// Set the `sender` field (required)
    pub fn sender(
        mut self,
        value: impl Into<convo::ReactionViewSender<S>>,
    ) -> ReactionViewBuilder<S, reaction_view_state::SetSender<St>> {
        self._fields.1 = Option::Some(value.into());
        ReactionViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> ReactionViewBuilder<S, St>
where
    St: reaction_view_state::State,
    St::Value: reaction_view_state::IsUnset,
{
    /// Set the `value` field (required)
    pub fn value(
        mut self,
        value: impl Into<S>,
    ) -> ReactionViewBuilder<S, reaction_view_state::SetValue<St>> {
        self._fields.2 = Option::Some(value.into());
        ReactionViewBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> ReactionViewBuilder<S, St>
where
    St: reaction_view_state::State,
    St::Value: reaction_view_state::IsSet,
    St::Sender: reaction_view_state::IsSet,
    St::CreatedAt: reaction_view_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> ReactionView<S> {
        ReactionView {
            created_at: self._fields.0.unwrap(),
            sender: self._fields.1.unwrap(),
            value: 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<SmolStr, Data<S>>,
    ) -> ReactionView<S> {
        ReactionView {
            created_at: self._fields.0.unwrap(),
            sender: self._fields.1.unwrap(),
            value: self._fields.2.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

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

/// Builder for constructing an instance of this type.
pub struct ReactionViewSenderBuilder<S: BosStr, St: reaction_view_sender_state::State> {
    _state: PhantomData<fn() -> St>,
    _fields: (Option<Did<S>>,),
    _type: PhantomData<fn() -> S>,
}

impl<S: BosStr> ReactionViewSender<S> {
    /// Create a new builder for this type.
    pub fn new() -> ReactionViewSenderBuilder<S, reaction_view_sender_state::Empty> {
        ReactionViewSenderBuilder::new()
    }
}

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

impl<S: BosStr, St> ReactionViewSenderBuilder<S, St>
where
    St: reaction_view_sender_state::State,
    St::Did: reaction_view_sender_state::IsUnset,
{
    /// Set the `did` field (required)
    pub fn did(
        mut self,
        value: impl Into<Did<S>>,
    ) -> ReactionViewSenderBuilder<S, reaction_view_sender_state::SetDid<St>> {
        self._fields.0 = Option::Some(value.into());
        ReactionViewSenderBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _type: PhantomData,
        }
    }
}

impl<S: BosStr, St> ReactionViewSenderBuilder<S, St>
where
    St: reaction_view_sender_state::State,
    St::Did: reaction_view_sender_state::IsSet,
{
    /// Build the final struct.
    pub fn build(self) -> ReactionViewSender<S> {
        ReactionViewSender {
            did: self._fields.0.unwrap(),
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data.
    pub fn build_with_data(
        self,
        extra_data: BTreeMap<SmolStr, Data<S>>,
    ) -> ReactionViewSender<S> {
        ReactionViewSender {
            did: self._fields.0.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}