shrike 0.1.5

// Code generated by lexgen. DO NOT EDIT.

/// ConvoDefsConvoKind is a string type from chat.bsky.convo.defs.
pub type ConvoDefsConvoKind = String;

/// ConvoDefsConvoLockStatus is a string type from chat.bsky.convo.defs.
pub type ConvoDefsConvoLockStatus = String;

/// ConvoDefsConvoRef object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsConvoRef {
    pub convo_id: String,
    pub did: crate::syntax::Did,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsConvoRef {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("did")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.did.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_did: Option<crate::syntax::Did> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "did" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_did = Some(
                            crate::syntax::Did::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsConvoRef {
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsConvoStatus is a string type from chat.bsky.convo.defs.
pub type ConvoDefsConvoStatus = String;

/// ConvoDefsConvoView object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsConvoView {
    pub id: String,
    /// Union field that has data specific to different kinds of convos.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<ConvoDefsConvoViewKindUnion>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_message: Option<ConvoDefsConvoViewLastMessageUnion>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_reaction: Option<ConvoDefsConvoViewLastReactionUnion>,
    /// Members of this conversation. For direct convos, it will be an immutable list of the 2 members. For group convos, it will a list of important members (the first few members, the viewer, the member who added the viewer, the member who sent the last message, the member who sent the last reaction), but will not contain the full list of members. Use chat.bsky.convo.getConvoMembers to list all members.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub members: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub muted: bool,
    pub rev: String,
    /// Convo status for the viewer member (not the convo itself).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<ConvoDefsConvoStatus>,
    pub unread_count: i64,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// Union field that has data specific to different kinds of convos.
#[derive(Debug, Clone)]
pub enum ConvoDefsConvoViewKindUnion {
    ConvoDefsDirectConvo(Box<ConvoDefsDirectConvo>),
    ConvoDefsGroupConvo(Box<ConvoDefsGroupConvo>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsConvoViewKindUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsConvoViewKindUnion::ConvoDefsDirectConvo(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#directConvo".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsConvoViewKindUnion::ConvoDefsGroupConvo(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#groupConvo".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsConvoViewKindUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsConvoViewKindUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#directConvo" => {
                let inner: ConvoDefsDirectConvo =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsConvoViewKindUnion::ConvoDefsDirectConvo(Box::new(
                    inner,
                )))
            }
            "chat.bsky.convo.defs#groupConvo" => {
                let inner: ConvoDefsGroupConvo =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsConvoViewKindUnion::ConvoDefsGroupConvo(Box::new(
                    inner,
                )))
            }
            _ => Ok(ConvoDefsConvoViewKindUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsConvoViewKindUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsConvoViewKindUnion::ConvoDefsDirectConvo(inner) => inner.encode_cbor(buf),
            ConvoDefsConvoViewKindUnion::ConvoDefsGroupConvo(inner) => inner.encode_cbor(buf),
            ConvoDefsConvoViewKindUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#directConvo" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsDirectConvo::decode_cbor(&mut dec)?;
                Ok(ConvoDefsConvoViewKindUnion::ConvoDefsDirectConvo(Box::new(
                    inner,
                )))
            }
            "chat.bsky.convo.defs#groupConvo" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsGroupConvo::decode_cbor(&mut dec)?;
                Ok(ConvoDefsConvoViewKindUnion::ConvoDefsGroupConvo(Box::new(
                    inner,
                )))
            }
            _ => Ok(ConvoDefsConvoViewKindUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

/// ConvoDefsConvoViewLastMessageUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsConvoViewLastMessageUnion {
    ConvoDefsMessageView(Box<ConvoDefsMessageView>),
    ConvoDefsDeletedMessageView(Box<ConvoDefsDeletedMessageView>),
    ConvoDefsSystemMessageView(Box<ConvoDefsSystemMessageView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsConvoViewLastMessageUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsConvoViewLastMessageUnion::ConvoDefsMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsConvoViewLastMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#deletedMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsConvoViewLastMessageUnion::ConvoDefsSystemMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsConvoViewLastMessageUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsConvoViewLastMessageUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let inner: ConvoDefsMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsConvoViewLastMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let inner: ConvoDefsDeletedMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsConvoViewLastMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            "chat.bsky.convo.defs#systemMessageView" => {
                let inner: ConvoDefsSystemMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsConvoViewLastMessageUnion::ConvoDefsSystemMessageView(Box::new(inner)))
            }
            _ => Ok(ConvoDefsConvoViewLastMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsConvoViewLastMessageUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsConvoViewLastMessageUnion::ConvoDefsMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsConvoViewLastMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsConvoViewLastMessageUnion::ConvoDefsSystemMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsConvoViewLastMessageUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsConvoViewLastMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsDeletedMessageView::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsConvoViewLastMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            "chat.bsky.convo.defs#systemMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsConvoViewLastMessageUnion::ConvoDefsSystemMessageView(Box::new(inner)))
            }
            _ => Ok(ConvoDefsConvoViewLastMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

/// ConvoDefsConvoViewLastReactionUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsConvoViewLastReactionUnion {
    ConvoDefsMessageAndReactionView(Box<ConvoDefsMessageAndReactionView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsConvoViewLastReactionUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsConvoViewLastReactionUnion::ConvoDefsMessageAndReactionView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#messageAndReactionView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsConvoViewLastReactionUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsConvoViewLastReactionUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageAndReactionView" => {
                let inner: ConvoDefsMessageAndReactionView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsConvoViewLastReactionUnion::ConvoDefsMessageAndReactionView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsConvoViewLastReactionUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsConvoViewLastReactionUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsConvoViewLastReactionUnion::ConvoDefsMessageAndReactionView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsConvoViewLastReactionUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageAndReactionView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsMessageAndReactionView::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsConvoViewLastReactionUnion::ConvoDefsMessageAndReactionView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsConvoViewLastReactionUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsConvoView {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 5u64;
            if self.kind.is_some() {
                count += 1;
            }
            if self.status.is_some() {
                count += 1;
            }
            if self.last_message.is_some() {
                count += 1;
            }
            if self.last_reaction.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("id")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            if self.kind.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("kind")?;
                if let Some(ref val) = self.kind {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("muted")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.muted)?;
            if self.status.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("status")?;
                if let Some(ref val) = self.status {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("members")?;
            crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.members.len() as u64)?;
            for item in &self.members {
                item.encode_cbor(buf)?;
            }
            if self.last_message.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastMessage")?;
                if let Some(ref val) = self.last_message {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("unreadCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.unread_count)?;
            if self.last_reaction.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastReaction")?;
                if let Some(ref val) = self.last_reaction {
                    val.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.id)?;
                pairs.push(("id", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            if self.kind.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.kind {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("kind", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_bool(self.muted)?;
                pairs.push(("muted", vbuf));
            }
            if self.status.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.status {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("status", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.members.len() as u64)?;
                for item in &self.members {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("members", vbuf));
            }
            if self.last_message.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_message {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("lastMessage", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.unread_count)?;
                pairs.push(("unreadCount", vbuf));
            }
            if self.last_reaction.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_reaction {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("lastReaction", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_id: Option<String> = None;
        let mut field_rev: Option<String> = None;
        let mut field_kind: Option<ConvoDefsConvoViewKindUnion> = None;
        let mut field_muted: Option<bool> = None;
        let mut field_status: Option<ConvoDefsConvoStatus> = None;
        let mut field_members: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> = Vec::new();
        let mut field_last_message: Option<ConvoDefsConvoViewLastMessageUnion> = None;
        let mut field_unread_count: Option<i64> = None;
        let mut field_last_reaction: Option<ConvoDefsConvoViewLastReactionUnion> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "id" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "kind" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_kind = Some(ConvoDefsConvoViewKindUnion::decode_cbor(&mut dec)?);
                }
                "muted" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_muted = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "status" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_status = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "members" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_members.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "lastMessage" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_last_message =
                        Some(ConvoDefsConvoViewLastMessageUnion::decode_cbor(&mut dec)?);
                }
                "unreadCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_unread_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_unread_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "lastReaction" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_last_reaction =
                        Some(ConvoDefsConvoViewLastReactionUnion::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsConvoView {
            id: field_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'id'".into())
            })?,
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            kind: field_kind,
            muted: field_muted.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'muted'".into())
            })?,
            status: field_status,
            members: field_members,
            last_message: field_last_message,
            unread_count: field_unread_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'unreadCount'".into())
            })?,
            last_reaction: field_last_reaction,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsDeletedMessageView object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsDeletedMessageView {
    pub id: String,
    pub rev: String,
    pub sender: ConvoDefsMessageViewSender,
    pub sent_at: crate::syntax::Datetime,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsDeletedMessageView {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("id")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("sender")?;
            self.sender.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("sentAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.sent_at.as_str())?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.id)?;
                pairs.push(("id", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.sender.encode_cbor(&mut vbuf)?;
                pairs.push(("sender", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.sent_at.as_str())?;
                pairs.push(("sentAt", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_id: Option<String> = None;
        let mut field_rev: Option<String> = None;
        let mut field_sender: Option<ConvoDefsMessageViewSender> = None;
        let mut field_sent_at: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "id" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "sender" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_sender = Some(ConvoDefsMessageViewSender::decode_cbor(&mut dec)?);
                }
                "sentAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_sent_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsDeletedMessageView {
            id: field_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'id'".into())
            })?,
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            sender: field_sender.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'sender'".into())
            })?,
            sent_at: field_sent_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'sentAt'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsDirectConvo — [NOTE: This is under active development and should be considered unstable while this note is here].
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsDirectConvo {
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsDirectConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 0u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsDirectConvo {
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsGroupConvo — [NOTE: This is under active development and should be considered unstable while this note is here].
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsGroupConvo {
    pub created_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub join_link: Option<crate::api::chat::bsky::GroupDefsJoinLinkView>,
    /// The total number of pending join requests for the group conversation. Only present for the owner. Capped at 21.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub join_request_count: Option<i64>,
    /// The lock status of the conversation.
    pub lock_status: ConvoDefsConvoLockStatus,
    /// The total number of members in the group conversation.
    pub member_count: i64,
    /// The maximum number of members allowed in the group conversation.
    pub member_limit: i64,
    /// The display name of the group conversation.
    pub name: String,
    /// The number of unread join requests for the group conversation. Only present for the owner.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub unread_join_request_count: Option<i64>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsGroupConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 5u64;
            if self.join_link.is_some() {
                count += 1;
            }
            if self.join_request_count.is_some() {
                count += 1;
            }
            if self.unread_join_request_count.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("name")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.name)?;
            if self.join_link.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("joinLink")?;
                if let Some(ref val) = self.join_link {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("lockStatus")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.lock_status)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("memberCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.member_count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("memberLimit")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.member_limit)?;
            if self.join_request_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("joinRequestCount")?;
                if let Some(ref val) = self.join_request_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.unread_join_request_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("unreadJoinRequestCount")?;
                if let Some(ref val) = self.unread_join_request_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.name)?;
                pairs.push(("name", vbuf));
            }
            if self.join_link.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.join_link {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("joinLink", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.lock_status)?;
                pairs.push(("lockStatus", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.member_count)?;
                pairs.push(("memberCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.member_limit)?;
                pairs.push(("memberLimit", vbuf));
            }
            if self.join_request_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.join_request_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("joinRequestCount", vbuf));
            }
            if self.unread_join_request_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.unread_join_request_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("unreadJoinRequestCount", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_name: Option<String> = None;
        let mut field_join_link: Option<crate::api::chat::bsky::GroupDefsJoinLinkView> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_lock_status: Option<ConvoDefsConvoLockStatus> = None;
        let mut field_member_count: Option<i64> = None;
        let mut field_member_limit: Option<i64> = None;
        let mut field_join_request_count: Option<i64> = None;
        let mut field_unread_join_request_count: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "name" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_name = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "joinLink" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_join_link = Some(
                        crate::api::chat::bsky::GroupDefsJoinLinkView::decode_cbor(&mut dec)?,
                    );
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "lockStatus" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_lock_status = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "memberCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_member_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_member_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "memberLimit" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_member_limit = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_member_limit = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "joinRequestCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_join_request_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_join_request_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "unreadJoinRequestCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_unread_join_request_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_unread_join_request_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsGroupConvo {
            name: field_name.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'name'".into())
            })?,
            join_link: field_join_link,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            lock_status: field_lock_status.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'lockStatus'".into())
            })?,
            member_count: field_member_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'memberCount'".into())
            })?,
            member_limit: field_member_limit.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'memberLimit'".into())
            })?,
            join_request_count: field_join_request_count,
            unread_join_request_count: field_unread_join_request_count,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogAcceptConvo — Event indicating the viewer accepted a convo, and it can be moved out of the request inbox. Can be direct or group.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogAcceptConvo {
    pub convo_id: String,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogAcceptConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogAcceptConvo {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogAddMember — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a member was added to a group convo. The member who was added gets a logBeginConvo (to create the convo) but also a logAddMember (to show the system message as the first message the user sees).
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogAddMember {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataAddMember
    pub message: ConvoDefsSystemMessageView,
    /// Profiles referred in the system message.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogAddMember {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.related_profiles.len() as u64)?;
            for item in &self.related_profiles {
                item.encode_cbor(buf)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogAddMember {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogAddReaction — Event indicating a reaction was added to a message.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogAddReaction {
    pub convo_id: String,
    pub message: ConvoDefsLogAddReactionMessageUnion,
    pub reaction: ConvoDefsReactionView,
    /// Profiles referred in the message and reaction views. This isn't required for compatibility, because it was added later, but should generally be present.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsLogAddReactionMessageUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsLogAddReactionMessageUnion {
    ConvoDefsMessageView(Box<ConvoDefsMessageView>),
    ConvoDefsDeletedMessageView(Box<ConvoDefsDeletedMessageView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsLogAddReactionMessageUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsLogAddReactionMessageUnion::ConvoDefsMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogAddReactionMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#deletedMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogAddReactionMessageUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsLogAddReactionMessageUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let inner: ConvoDefsMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsLogAddReactionMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let inner: ConvoDefsDeletedMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsLogAddReactionMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogAddReactionMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsLogAddReactionMessageUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsLogAddReactionMessageUnion::ConvoDefsMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogAddReactionMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogAddReactionMessageUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsLogAddReactionMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsDeletedMessageView::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsLogAddReactionMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogAddReactionMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsLogAddReaction {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 4u64;
            if !self.related_profiles.is_empty() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("reaction")?;
            self.reaction.encode_cbor(buf)?;
            if !self.related_profiles.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.reaction.encode_cbor(&mut vbuf)?;
                pairs.push(("reaction", vbuf));
            }
            if !self.related_profiles.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsLogAddReactionMessageUnion> = None;
        let mut field_reaction: Option<ConvoDefsReactionView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message =
                        Some(ConvoDefsLogAddReactionMessageUnion::decode_cbor(&mut dec)?);
                }
                "reaction" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_reaction = Some(ConvoDefsReactionView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogAddReaction {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            reaction: field_reaction.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'reaction'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogApproveJoinRequest — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join request was approved by the viewer. Only the owner gets this. The approved member gets a logBeginConvo.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogApproveJoinRequest {
    pub convo_id: String,
    /// Prospective member who requested to join.
    pub member: crate::api::chat::bsky::ActorDefsProfileViewBasic,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogApproveJoinRequest {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("member")?;
            self.member.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.member.encode_cbor(&mut vbuf)?;
                pairs.push(("member", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_member: Option<crate::api::chat::bsky::ActorDefsProfileViewBasic> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "member" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_member = Some(
                        crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(&mut dec)?,
                    );
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogApproveJoinRequest {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            member: field_member.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'member'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogBeginConvo — Event indicating a convo containing the viewer was started. Can be direct or group. When a member is added to a group convo, they also get this event.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogBeginConvo {
    pub convo_id: String,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogBeginConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogBeginConvo {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogCreateJoinLink — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join link was created for a group convo.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogCreateJoinLink {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataCreateJoinLink
    pub message: ConvoDefsSystemMessageView,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogCreateJoinLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogCreateJoinLink {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogCreateMessage — Event indicating a user-originated message was created. Is not emitted for system messages.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogCreateMessage {
    pub convo_id: String,
    pub message: ConvoDefsLogCreateMessageMessageUnion,
    /// Profiles referred to in the message view. This isn't required for compatibility, because it was added later, but should generally be present.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsLogCreateMessageMessageUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsLogCreateMessageMessageUnion {
    ConvoDefsMessageView(Box<ConvoDefsMessageView>),
    ConvoDefsDeletedMessageView(Box<ConvoDefsDeletedMessageView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsLogCreateMessageMessageUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsLogCreateMessageMessageUnion::ConvoDefsMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogCreateMessageMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#deletedMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogCreateMessageMessageUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsLogCreateMessageMessageUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let inner: ConvoDefsMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsLogCreateMessageMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let inner: ConvoDefsDeletedMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsLogCreateMessageMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogCreateMessageMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsLogCreateMessageMessageUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsLogCreateMessageMessageUnion::ConvoDefsMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogCreateMessageMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogCreateMessageMessageUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsLogCreateMessageMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsDeletedMessageView::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsLogCreateMessageMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogCreateMessageMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsLogCreateMessage {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 3u64;
            if !self.related_profiles.is_empty() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            if !self.related_profiles.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            if !self.related_profiles.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsLogCreateMessageMessageUnion> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsLogCreateMessageMessageUnion::decode_cbor(
                        &mut dec,
                    )?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogCreateMessage {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogDeleteMessage — Event indicating a user-originated message was deleted. Is not emitted for system messages.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogDeleteMessage {
    pub convo_id: String,
    pub message: ConvoDefsLogDeleteMessageMessageUnion,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsLogDeleteMessageMessageUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsLogDeleteMessageMessageUnion {
    ConvoDefsMessageView(Box<ConvoDefsMessageView>),
    ConvoDefsDeletedMessageView(Box<ConvoDefsDeletedMessageView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsLogDeleteMessageMessageUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsLogDeleteMessageMessageUnion::ConvoDefsMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogDeleteMessageMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#deletedMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogDeleteMessageMessageUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsLogDeleteMessageMessageUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let inner: ConvoDefsMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsLogDeleteMessageMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let inner: ConvoDefsDeletedMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsLogDeleteMessageMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogDeleteMessageMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsLogDeleteMessageMessageUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsLogDeleteMessageMessageUnion::ConvoDefsMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogDeleteMessageMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogDeleteMessageMessageUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsLogDeleteMessageMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsDeletedMessageView::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsLogDeleteMessageMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogDeleteMessageMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsLogDeleteMessage {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsLogDeleteMessageMessageUnion> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsLogDeleteMessageMessageUnion::decode_cbor(
                        &mut dec,
                    )?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogDeleteMessage {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogDisableJoinLink — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join link was disabled for a group convo.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogDisableJoinLink {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataDisableJoinLink
    pub message: ConvoDefsSystemMessageView,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogDisableJoinLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogDisableJoinLink {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogEditGroup — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating info about group convo was edited.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogEditGroup {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataEditGroup
    pub message: ConvoDefsSystemMessageView,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogEditGroup {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogEditGroup {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogEditJoinLink — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a settings about a join link for a group convo were edited.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogEditJoinLink {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataEditJoinLink
    pub message: ConvoDefsSystemMessageView,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogEditJoinLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogEditJoinLink {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogEnableJoinLink — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join link was enabled for a group convo.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogEnableJoinLink {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataEnableJoinLink
    pub message: ConvoDefsSystemMessageView,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogEnableJoinLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogEnableJoinLink {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogIncomingJoinRequest — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join request was made to a group the viewer owns. Only the owner gets this.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogIncomingJoinRequest {
    pub convo_id: String,
    /// Prospective member who requested to join.
    pub member: crate::api::chat::bsky::ActorDefsProfileViewBasic,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogIncomingJoinRequest {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("member")?;
            self.member.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.member.encode_cbor(&mut vbuf)?;
                pairs.push(("member", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_member: Option<crate::api::chat::bsky::ActorDefsProfileViewBasic> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "member" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_member = Some(
                        crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(&mut dec)?,
                    );
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogIncomingJoinRequest {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            member: field_member.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'member'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogLeaveConvo — Event indicating the viewer left a convo. Can be direct or group.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogLeaveConvo {
    pub convo_id: String,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogLeaveConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogLeaveConvo {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogLockConvo — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a group convo was locked.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogLockConvo {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataLockConvo
    pub message: ConvoDefsSystemMessageView,
    /// Profiles referred in the system message.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogLockConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.related_profiles.len() as u64)?;
            for item in &self.related_profiles {
                item.encode_cbor(buf)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogLockConvo {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogLockConvoPermanently — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a group convo was locked permanently.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogLockConvoPermanently {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataLockConvoPermanently
    pub message: ConvoDefsSystemMessageView,
    /// Profiles referred in the system message.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogLockConvoPermanently {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.related_profiles.len() as u64)?;
            for item in &self.related_profiles {
                item.encode_cbor(buf)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogLockConvoPermanently {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogMemberJoin — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a member joined a group convo via join link. The member who was added gets a logBeginConvo (to create the convo) but also a logMemberJoin (to show the system message as the first message the user sees).
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogMemberJoin {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataMemberJoin
    pub message: ConvoDefsSystemMessageView,
    /// Profiles referred in the system message.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogMemberJoin {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.related_profiles.len() as u64)?;
            for item in &self.related_profiles {
                item.encode_cbor(buf)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogMemberJoin {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogMemberLeave — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a member voluntarily left a group convo. The member who was removed gets a logLeaveConvo (to leave the convo) but not a logMemberLeave (because they already left, so can't see the system message).
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogMemberLeave {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataMemberLeave
    pub message: ConvoDefsSystemMessageView,
    /// Profiles referred in the system message.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogMemberLeave {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.related_profiles.len() as u64)?;
            for item in &self.related_profiles {
                item.encode_cbor(buf)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogMemberLeave {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogMuteConvo — Event indicating the viewer muted a convo. Can be direct or group.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogMuteConvo {
    pub convo_id: String,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogMuteConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogMuteConvo {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogOutgoingJoinRequest — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join request was made by the requester. Only requester actor gets this.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogOutgoingJoinRequest {
    pub convo_id: String,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogOutgoingJoinRequest {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogOutgoingJoinRequest {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogReadConvo — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a convo was read up to a certain message.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogReadConvo {
    pub convo_id: String,
    pub message: ConvoDefsLogReadConvoMessageUnion,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsLogReadConvoMessageUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsLogReadConvoMessageUnion {
    ConvoDefsMessageView(Box<ConvoDefsMessageView>),
    ConvoDefsDeletedMessageView(Box<ConvoDefsDeletedMessageView>),
    ConvoDefsSystemMessageView(Box<ConvoDefsSystemMessageView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsLogReadConvoMessageUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsLogReadConvoMessageUnion::ConvoDefsMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogReadConvoMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#deletedMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogReadConvoMessageUnion::ConvoDefsSystemMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogReadConvoMessageUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsLogReadConvoMessageUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let inner: ConvoDefsMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsLogReadConvoMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let inner: ConvoDefsDeletedMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsLogReadConvoMessageUnion::ConvoDefsDeletedMessageView(Box::new(inner)))
            }
            "chat.bsky.convo.defs#systemMessageView" => {
                let inner: ConvoDefsSystemMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsLogReadConvoMessageUnion::ConvoDefsSystemMessageView(Box::new(inner)))
            }
            _ => Ok(ConvoDefsLogReadConvoMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsLogReadConvoMessageUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsLogReadConvoMessageUnion::ConvoDefsMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogReadConvoMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogReadConvoMessageUnion::ConvoDefsSystemMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogReadConvoMessageUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsLogReadConvoMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsDeletedMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsLogReadConvoMessageUnion::ConvoDefsDeletedMessageView(Box::new(inner)))
            }
            "chat.bsky.convo.defs#systemMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsLogReadConvoMessageUnion::ConvoDefsSystemMessageView(Box::new(inner)))
            }
            _ => Ok(ConvoDefsLogReadConvoMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsLogReadConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsLogReadConvoMessageUnion> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsLogReadConvoMessageUnion::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogReadConvo {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogReadJoinRequests — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating the group owner marked join requests as read. Only the owner gets this.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogReadJoinRequests {
    pub convo_id: String,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogReadJoinRequests {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogReadJoinRequests {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogReadMessage — DEPRECATED: use logReadConvo instead. Event indicating a convo was read up to a certain message.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogReadMessage {
    pub convo_id: String,
    pub message: ConvoDefsLogReadMessageMessageUnion,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsLogReadMessageMessageUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsLogReadMessageMessageUnion {
    ConvoDefsMessageView(Box<ConvoDefsMessageView>),
    ConvoDefsDeletedMessageView(Box<ConvoDefsDeletedMessageView>),
    ConvoDefsSystemMessageView(Box<ConvoDefsSystemMessageView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsLogReadMessageMessageUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsLogReadMessageMessageUnion::ConvoDefsMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogReadMessageMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#deletedMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogReadMessageMessageUnion::ConvoDefsSystemMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogReadMessageMessageUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsLogReadMessageMessageUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let inner: ConvoDefsMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsLogReadMessageMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let inner: ConvoDefsDeletedMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsLogReadMessageMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            "chat.bsky.convo.defs#systemMessageView" => {
                let inner: ConvoDefsSystemMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsLogReadMessageMessageUnion::ConvoDefsSystemMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogReadMessageMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsLogReadMessageMessageUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsLogReadMessageMessageUnion::ConvoDefsMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogReadMessageMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogReadMessageMessageUnion::ConvoDefsSystemMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogReadMessageMessageUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsLogReadMessageMessageUnion::ConvoDefsMessageView(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsDeletedMessageView::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsLogReadMessageMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            "chat.bsky.convo.defs#systemMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageView::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsLogReadMessageMessageUnion::ConvoDefsSystemMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogReadMessageMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsLogReadMessage {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsLogReadMessageMessageUnion> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message =
                        Some(ConvoDefsLogReadMessageMessageUnion::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogReadMessage {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogRejectJoinRequest — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join request was rejected by the viewer. Only the owner gets this.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogRejectJoinRequest {
    pub convo_id: String,
    /// Prospective member who requested to join.
    pub member: crate::api::chat::bsky::ActorDefsProfileViewBasic,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogRejectJoinRequest {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("member")?;
            self.member.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.member.encode_cbor(&mut vbuf)?;
                pairs.push(("member", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_member: Option<crate::api::chat::bsky::ActorDefsProfileViewBasic> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "member" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_member = Some(
                        crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(&mut dec)?,
                    );
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogRejectJoinRequest {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            member: field_member.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'member'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogRemoveMember — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a member was removed from a group convo. The member who was removed gets a logLeaveConvo (to leave the convo) but not a logRemoveMember (because they already left, so can't see the system message).
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogRemoveMember {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataRemoveMember
    pub message: ConvoDefsSystemMessageView,
    /// Profiles referred in the system message.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogRemoveMember {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.related_profiles.len() as u64)?;
            for item in &self.related_profiles {
                item.encode_cbor(buf)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogRemoveMember {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogRemoveReaction — Event indicating a reaction was removed from a message.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogRemoveReaction {
    pub convo_id: String,
    pub message: ConvoDefsLogRemoveReactionMessageUnion,
    pub reaction: ConvoDefsReactionView,
    /// Profiles referred in the message and reaction views. This isn't required for compatibility, because it was added later, but should generally be present.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsLogRemoveReactionMessageUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsLogRemoveReactionMessageUnion {
    ConvoDefsMessageView(Box<ConvoDefsMessageView>),
    ConvoDefsDeletedMessageView(Box<ConvoDefsDeletedMessageView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsLogRemoveReactionMessageUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsLogRemoveReactionMessageUnion::ConvoDefsMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogRemoveReactionMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#deletedMessageView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsLogRemoveReactionMessageUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsLogRemoveReactionMessageUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let inner: ConvoDefsMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsLogRemoveReactionMessageUnion::ConvoDefsMessageView(Box::new(inner)))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let inner: ConvoDefsDeletedMessageView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsLogRemoveReactionMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogRemoveReactionMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsLogRemoveReactionMessageUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsLogRemoveReactionMessageUnion::ConvoDefsMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogRemoveReactionMessageUnion::ConvoDefsDeletedMessageView(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsLogRemoveReactionMessageUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#messageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsMessageView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsLogRemoveReactionMessageUnion::ConvoDefsMessageView(Box::new(inner)))
            }
            "chat.bsky.convo.defs#deletedMessageView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsDeletedMessageView::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsLogRemoveReactionMessageUnion::ConvoDefsDeletedMessageView(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ConvoDefsLogRemoveReactionMessageUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsLogRemoveReaction {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 4u64;
            if !self.related_profiles.is_empty() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("reaction")?;
            self.reaction.encode_cbor(buf)?;
            if !self.related_profiles.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.reaction.encode_cbor(&mut vbuf)?;
                pairs.push(("reaction", vbuf));
            }
            if !self.related_profiles.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsLogRemoveReactionMessageUnion> = None;
        let mut field_reaction: Option<ConvoDefsReactionView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsLogRemoveReactionMessageUnion::decode_cbor(
                        &mut dec,
                    )?);
                }
                "reaction" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_reaction = Some(ConvoDefsReactionView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogRemoveReaction {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            reaction: field_reaction.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'reaction'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogUnlockConvo — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a group convo was unlocked.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogUnlockConvo {
    pub convo_id: String,
    /// A system message with data of type #systemMessageDataUnlockConvo
    pub message: ConvoDefsSystemMessageView,
    /// Profiles referred in the system message.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic>,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogUnlockConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("relatedProfiles")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.related_profiles.len() as u64)?;
            for item in &self.related_profiles {
                item.encode_cbor(buf)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.related_profiles.len() as u64)?;
                for item in &self.related_profiles {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("relatedProfiles", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message: Option<ConvoDefsSystemMessageView> = None;
        let mut field_related_profiles: Vec<crate::api::chat::bsky::ActorDefsProfileViewBasic> =
            Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsSystemMessageView::decode_cbor(&mut dec)?);
                }
                "relatedProfiles" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_related_profiles.push(
                                crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogUnlockConvo {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            related_profiles: field_related_profiles,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogUnmuteConvo — Event indicating the viewer unmuted a convo. Can be direct or group.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogUnmuteConvo {
    pub convo_id: String,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogUnmuteConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogUnmuteConvo {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogWithdrawIncomingJoinRequest — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a prospective member withdrew their join request. Only the owner gets this.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogWithdrawIncomingJoinRequest {
    pub convo_id: String,
    /// Prospective member who withdrew their join request.
    pub member: crate::api::chat::bsky::ActorDefsProfileViewBasic,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogWithdrawIncomingJoinRequest {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("member")?;
            self.member.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.member.encode_cbor(&mut vbuf)?;
                pairs.push(("member", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_member: Option<crate::api::chat::bsky::ActorDefsProfileViewBasic> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "member" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_member = Some(
                        crate::api::chat::bsky::ActorDefsProfileViewBasic::decode_cbor(&mut dec)?,
                    );
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogWithdrawIncomingJoinRequest {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            member: field_member.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'member'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsLogWithdrawOutgoingJoinRequest — [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating the viewer withdrew their own join request. Only requester actor gets this.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsLogWithdrawOutgoingJoinRequest {
    pub convo_id: String,
    pub rev: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsLogWithdrawOutgoingJoinRequest {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_rev: Option<String> = None;
        let mut field_convo_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsLogWithdrawOutgoingJoinRequest {
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsMessageAndReactionView object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsMessageAndReactionView {
    pub message: ConvoDefsMessageView,
    pub reaction: ConvoDefsReactionView,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsMessageAndReactionView {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("message")?;
            self.message.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("reaction")?;
            self.reaction.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                self.message.encode_cbor(&mut vbuf)?;
                pairs.push(("message", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.reaction.encode_cbor(&mut vbuf)?;
                pairs.push(("reaction", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_message: Option<ConvoDefsMessageView> = None;
        let mut field_reaction: Option<ConvoDefsReactionView> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "message" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_message = Some(ConvoDefsMessageView::decode_cbor(&mut dec)?);
                }
                "reaction" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_reaction = Some(ConvoDefsReactionView::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsMessageAndReactionView {
            message: field_message.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'message'".into())
            })?,
            reaction: field_reaction.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'reaction'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsMessageInput object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsMessageInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub embed: Option<ConvoDefsMessageInputEmbedUnion>,
    /// Annotations of text (mentions, URLs, hashtags, etc)
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub facets: Vec<crate::api::app::bsky::RichtextFacet>,
    pub text: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsMessageInputEmbedUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsMessageInputEmbedUnion {
    EmbedRecord(Box<crate::api::app::bsky::EmbedRecord>),
    EmbedJoinLink(Box<crate::api::chat::bsky::EmbedJoinLink>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsMessageInputEmbedUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsMessageInputEmbedUnion::EmbedRecord(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("app.bsky.embed.record".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsMessageInputEmbedUnion::EmbedJoinLink(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.embed.joinLink".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsMessageInputEmbedUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsMessageInputEmbedUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "app.bsky.embed.record" => {
                let inner: crate::api::app::bsky::EmbedRecord =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsMessageInputEmbedUnion::EmbedRecord(Box::new(
                    inner,
                )))
            }
            "chat.bsky.embed.joinLink" => {
                let inner: crate::api::chat::bsky::EmbedJoinLink =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsMessageInputEmbedUnion::EmbedJoinLink(Box::new(
                    inner,
                )))
            }
            _ => Ok(ConvoDefsMessageInputEmbedUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsMessageInputEmbedUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsMessageInputEmbedUnion::EmbedRecord(inner) => inner.encode_cbor(buf),
            ConvoDefsMessageInputEmbedUnion::EmbedJoinLink(inner) => inner.encode_cbor(buf),
            ConvoDefsMessageInputEmbedUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "app.bsky.embed.record" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::app::bsky::EmbedRecord::decode_cbor(&mut dec)?;
                Ok(ConvoDefsMessageInputEmbedUnion::EmbedRecord(Box::new(
                    inner,
                )))
            }
            "chat.bsky.embed.joinLink" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::chat::bsky::EmbedJoinLink::decode_cbor(&mut dec)?;
                Ok(ConvoDefsMessageInputEmbedUnion::EmbedJoinLink(Box::new(
                    inner,
                )))
            }
            _ => Ok(ConvoDefsMessageInputEmbedUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsMessageInput {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 1u64;
            if self.embed.is_some() {
                count += 1;
            }
            if !self.facets.is_empty() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("text")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.text)?;
            if self.embed.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("embed")?;
                if let Some(ref val) = self.embed {
                    val.encode_cbor(buf)?;
                }
            }
            if !self.facets.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("facets")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.facets.len() as u64)?;
                for item in &self.facets {
                    item.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.text)?;
                pairs.push(("text", vbuf));
            }
            if self.embed.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.embed {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("embed", vbuf));
            }
            if !self.facets.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.facets.len() as u64)?;
                for item in &self.facets {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("facets", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_text: Option<String> = None;
        let mut field_embed: Option<ConvoDefsMessageInputEmbedUnion> = None;
        let mut field_facets: Vec<crate::api::app::bsky::RichtextFacet> = Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "text" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_text = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "embed" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_embed = Some(ConvoDefsMessageInputEmbedUnion::decode_cbor(&mut dec)?);
                }
                "facets" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_facets
                                .push(crate::api::app::bsky::RichtextFacet::decode_cbor(&mut dec)?);
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsMessageInput {
            text: field_text.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'text'".into())
            })?,
            embed: field_embed,
            facets: field_facets,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsMessageRef object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsMessageRef {
    pub convo_id: String,
    pub did: crate::syntax::Did,
    pub message_id: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsMessageRef {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("did")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.did.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("convoId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.convo_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("messageId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.message_id)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.convo_id)?;
                pairs.push(("convoId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.message_id)?;
                pairs.push(("messageId", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_did: Option<crate::syntax::Did> = None;
        let mut field_convo_id: Option<String> = None;
        let mut field_message_id: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "did" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_did = Some(
                            crate::syntax::Did::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "convoId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_convo_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "messageId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_message_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsMessageRef {
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            convo_id: field_convo_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'convoId'".into())
            })?,
            message_id: field_message_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'messageId'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsMessageView object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsMessageView {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub embed: Option<ConvoDefsMessageViewEmbedUnion>,
    /// Annotations of text (mentions, URLs, hashtags, etc)
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub facets: Vec<crate::api::app::bsky::RichtextFacet>,
    pub id: String,
    /// Reactions to this message, in ascending order of creation time.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub reactions: Vec<ConvoDefsReactionView>,
    pub rev: String,
    pub sender: ConvoDefsMessageViewSender,
    pub sent_at: crate::syntax::Datetime,
    pub text: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsMessageViewEmbedUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsMessageViewEmbedUnion {
    EmbedRecordView(Box<crate::api::app::bsky::EmbedRecordView>),
    EmbedJoinLinkView(Box<crate::api::chat::bsky::EmbedJoinLinkView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsMessageViewEmbedUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsMessageViewEmbedUnion::EmbedRecordView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("app.bsky.embed.record#view".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsMessageViewEmbedUnion::EmbedJoinLinkView(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.embed.joinLink#view".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsMessageViewEmbedUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsMessageViewEmbedUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "app.bsky.embed.record#view" => {
                let inner: crate::api::app::bsky::EmbedRecordView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsMessageViewEmbedUnion::EmbedRecordView(Box::new(
                    inner,
                )))
            }
            "chat.bsky.embed.joinLink#view" => {
                let inner: crate::api::chat::bsky::EmbedJoinLinkView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsMessageViewEmbedUnion::EmbedJoinLinkView(Box::new(
                    inner,
                )))
            }
            _ => Ok(ConvoDefsMessageViewEmbedUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsMessageViewEmbedUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsMessageViewEmbedUnion::EmbedRecordView(inner) => inner.encode_cbor(buf),
            ConvoDefsMessageViewEmbedUnion::EmbedJoinLinkView(inner) => inner.encode_cbor(buf),
            ConvoDefsMessageViewEmbedUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "app.bsky.embed.record#view" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::app::bsky::EmbedRecordView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsMessageViewEmbedUnion::EmbedRecordView(Box::new(
                    inner,
                )))
            }
            "chat.bsky.embed.joinLink#view" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::chat::bsky::EmbedJoinLinkView::decode_cbor(&mut dec)?;
                Ok(ConvoDefsMessageViewEmbedUnion::EmbedJoinLinkView(Box::new(
                    inner,
                )))
            }
            _ => Ok(ConvoDefsMessageViewEmbedUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsMessageView {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 5u64;
            if self.embed.is_some() {
                count += 1;
            }
            if !self.facets.is_empty() {
                count += 1;
            }
            if !self.reactions.is_empty() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("id")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("text")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.text)?;
            if self.embed.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("embed")?;
                if let Some(ref val) = self.embed {
                    val.encode_cbor(buf)?;
                }
            }
            if !self.facets.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("facets")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.facets.len() as u64)?;
                for item in &self.facets {
                    item.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("sender")?;
            self.sender.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("sentAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.sent_at.as_str())?;
            if !self.reactions.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reactions")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.reactions.len() as u64)?;
                for item in &self.reactions {
                    item.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.id)?;
                pairs.push(("id", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.text)?;
                pairs.push(("text", vbuf));
            }
            if self.embed.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.embed {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("embed", vbuf));
            }
            if !self.facets.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.facets.len() as u64)?;
                for item in &self.facets {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("facets", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.sender.encode_cbor(&mut vbuf)?;
                pairs.push(("sender", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.sent_at.as_str())?;
                pairs.push(("sentAt", vbuf));
            }
            if !self.reactions.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.reactions.len() as u64)?;
                for item in &self.reactions {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("reactions", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_id: Option<String> = None;
        let mut field_rev: Option<String> = None;
        let mut field_text: Option<String> = None;
        let mut field_embed: Option<ConvoDefsMessageViewEmbedUnion> = None;
        let mut field_facets: Vec<crate::api::app::bsky::RichtextFacet> = Vec::new();
        let mut field_sender: Option<ConvoDefsMessageViewSender> = None;
        let mut field_sent_at: Option<crate::syntax::Datetime> = None;
        let mut field_reactions: Vec<ConvoDefsReactionView> = Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "id" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "text" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_text = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "embed" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_embed = Some(ConvoDefsMessageViewEmbedUnion::decode_cbor(&mut dec)?);
                }
                "facets" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_facets
                                .push(crate::api::app::bsky::RichtextFacet::decode_cbor(&mut dec)?);
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "sender" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_sender = Some(ConvoDefsMessageViewSender::decode_cbor(&mut dec)?);
                }
                "sentAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_sent_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "reactions" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            let raw = crate::cbor::encode_value(&item)?;
                            let mut dec = crate::cbor::Decoder::new(&raw);
                            field_reactions.push(ConvoDefsReactionView::decode_cbor(&mut dec)?);
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsMessageView {
            id: field_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'id'".into())
            })?,
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            text: field_text.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'text'".into())
            })?,
            embed: field_embed,
            facets: field_facets,
            sender: field_sender.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'sender'".into())
            })?,
            sent_at: field_sent_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'sentAt'".into())
            })?,
            reactions: field_reactions,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsMessageViewSender object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsMessageViewSender {
    pub did: crate::syntax::Did,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsMessageViewSender {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 1u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("did")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.did.as_str())?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_did: Option<crate::syntax::Did> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "did" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_did = Some(
                            crate::syntax::Did::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsMessageViewSender {
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsReactionView object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsReactionView {
    pub created_at: crate::syntax::Datetime,
    pub sender: ConvoDefsReactionViewSender,
    pub value: String,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsReactionView {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("value")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.value)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("sender")?;
            self.sender.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.value)?;
                pairs.push(("value", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.sender.encode_cbor(&mut vbuf)?;
                pairs.push(("sender", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_value: Option<String> = None;
        let mut field_sender: Option<ConvoDefsReactionViewSender> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "value" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_value = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "sender" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_sender = Some(ConvoDefsReactionViewSender::decode_cbor(&mut dec)?);
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsReactionView {
            value: field_value.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'value'".into())
            })?,
            sender: field_sender.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'sender'".into())
            })?,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsReactionViewSender object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsReactionViewSender {
    pub did: crate::syntax::Did,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsReactionViewSender {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 1u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("did")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.did.as_str())?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_did: Option<crate::syntax::Did> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "did" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_did = Some(
                            crate::syntax::Did::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsReactionViewSender {
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataAddMember — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating a user was added to the group convo.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataAddMember {
    pub added_by: ConvoDefsSystemMessageReferredUser,
    /// Current view of the member who was added.
    pub member: ConvoDefsSystemMessageReferredUser,
    /// Role the user was added to the group with. The role from 'member' will reflect the current data, not historical.
    pub role: crate::api::chat::bsky::ActorDefsMemberRole,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataAddMember {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 3u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("role")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.role)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("member")?;
            self.member.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("addedBy")?;
            self.added_by.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.role)?;
                pairs.push(("role", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.member.encode_cbor(&mut vbuf)?;
                pairs.push(("member", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.added_by.encode_cbor(&mut vbuf)?;
                pairs.push(("addedBy", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_role: Option<crate::api::chat::bsky::ActorDefsMemberRole> = None;
        let mut field_member: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut field_added_by: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "role" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_role = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "member" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_member = Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                "addedBy" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_added_by =
                        Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataAddMember {
            role: field_role.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'role'".into())
            })?,
            member: field_member.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'member'".into())
            })?,
            added_by: field_added_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'addedBy'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataCreateJoinLink — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group join link was created.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataCreateJoinLink {
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataCreateJoinLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 0u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataCreateJoinLink {
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataDisableJoinLink — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group join link was disabled.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataDisableJoinLink {
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataDisableJoinLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 0u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataDisableJoinLink {
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataEditGroup — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group info was edited.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataEditGroup {
    /// Group name that replaced the old.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub new_name: Option<String>,
    /// Group name that was replaced.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub old_name: Option<String>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataEditGroup {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 0u64;
            if self.new_name.is_some() {
                count += 1;
            }
            if self.old_name.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.new_name.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("newName")?;
                if let Some(ref val) = self.new_name {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.old_name.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("oldName")?;
                if let Some(ref val) = self.old_name {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.new_name.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.new_name {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("newName", vbuf));
            }
            if self.old_name.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.old_name {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("oldName", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_new_name: Option<String> = None;
        let mut field_old_name: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "newName" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_new_name = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "oldName" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_old_name = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataEditGroup {
            new_name: field_new_name,
            old_name: field_old_name,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataEditJoinLink — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group join link was edited.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataEditJoinLink {
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataEditJoinLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 0u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataEditJoinLink {
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataEnableJoinLink — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group join link was enabled.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataEnableJoinLink {
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataEnableJoinLink {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 0u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataEnableJoinLink {
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataLockConvo — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group convo was locked.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataLockConvo {
    /// Current view of the member who locked the group.
    pub locked_by: ConvoDefsSystemMessageReferredUser,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataLockConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 1u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("lockedBy")?;
            self.locked_by.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                self.locked_by.encode_cbor(&mut vbuf)?;
                pairs.push(("lockedBy", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_locked_by: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "lockedBy" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_locked_by =
                        Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataLockConvo {
            locked_by: field_locked_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'lockedBy'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataLockConvoPermanently — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group convo was locked permanently.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataLockConvoPermanently {
    /// Current view of the member who locked the group.
    pub locked_by: ConvoDefsSystemMessageReferredUser,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataLockConvoPermanently {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 1u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("lockedBy")?;
            self.locked_by.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                self.locked_by.encode_cbor(&mut vbuf)?;
                pairs.push(("lockedBy", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_locked_by: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "lockedBy" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_locked_by =
                        Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataLockConvoPermanently {
            locked_by: field_locked_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'lockedBy'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataMemberJoin — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating a user joined the group convo via join link.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataMemberJoin {
    /// If join link was configured to require approval, this will be set to who approved the request. Undefined if approval was not required.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approved_by: Option<ConvoDefsSystemMessageReferredUser>,
    /// Current view of the member who joined.
    pub member: ConvoDefsSystemMessageReferredUser,
    /// Role the user was added to the group with. The role from 'member' will reflect the current data, not historical.
    pub role: crate::api::chat::bsky::ActorDefsMemberRole,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataMemberJoin {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 2u64;
            if self.approved_by.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("role")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.role)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("member")?;
            self.member.encode_cbor(buf)?;
            if self.approved_by.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("approvedBy")?;
                if let Some(ref val) = self.approved_by {
                    val.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.role)?;
                pairs.push(("role", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.member.encode_cbor(&mut vbuf)?;
                pairs.push(("member", vbuf));
            }
            if self.approved_by.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.approved_by {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("approvedBy", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_role: Option<crate::api::chat::bsky::ActorDefsMemberRole> = None;
        let mut field_member: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut field_approved_by: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "role" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_role = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "member" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_member = Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                "approvedBy" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_approved_by =
                        Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataMemberJoin {
            role: field_role.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'role'".into())
            })?,
            member: field_member.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'member'".into())
            })?,
            approved_by: field_approved_by,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataMemberLeave — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating a user voluntarily left the group convo.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataMemberLeave {
    /// Current view of the member who left the group.
    pub member: ConvoDefsSystemMessageReferredUser,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataMemberLeave {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 1u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("member")?;
            self.member.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                self.member.encode_cbor(&mut vbuf)?;
                pairs.push(("member", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_member: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "member" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_member = Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataMemberLeave {
            member: field_member.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'member'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataRemoveMember — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating a user was removed from the group convo.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataRemoveMember {
    /// Current view of the member who was removed.
    pub member: ConvoDefsSystemMessageReferredUser,
    pub removed_by: ConvoDefsSystemMessageReferredUser,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataRemoveMember {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 2u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("member")?;
            self.member.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("removedBy")?;
            self.removed_by.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                self.member.encode_cbor(&mut vbuf)?;
                pairs.push(("member", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.removed_by.encode_cbor(&mut vbuf)?;
                pairs.push(("removedBy", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_member: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut field_removed_by: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "member" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_member = Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                "removedBy" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_removed_by =
                        Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataRemoveMember {
            member: field_member.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'member'".into())
            })?,
            removed_by: field_removed_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'removedBy'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageDataUnlockConvo — [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group convo was unlocked.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageDataUnlockConvo {
    /// Current view of the member who unlocked the group.
    pub unlocked_by: ConvoDefsSystemMessageReferredUser,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageDataUnlockConvo {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 1u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("unlockedBy")?;
            self.unlocked_by.encode_cbor(buf)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                self.unlocked_by.encode_cbor(&mut vbuf)?;
                pairs.push(("unlockedBy", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_unlocked_by: Option<ConvoDefsSystemMessageReferredUser> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "unlockedBy" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_unlocked_by =
                        Some(ConvoDefsSystemMessageReferredUser::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageDataUnlockConvo {
            unlocked_by: field_unlocked_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'unlockedBy'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageReferredUser object from chat.bsky.convo.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageReferredUser {
    pub did: crate::syntax::Did,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ConvoDefsSystemMessageReferredUser {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 1u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("did")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.did.as_str())?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_did: Option<crate::syntax::Did> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "did" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_did = Some(
                            crate::syntax::Did::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageReferredUser {
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ConvoDefsSystemMessageView — [NOTE: This is under active development and should be considered unstable while this note is here].
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoDefsSystemMessageView {
    pub data: ConvoDefsSystemMessageViewDataUnion,
    pub id: String,
    pub rev: String,
    pub sent_at: crate::syntax::Datetime,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

/// ConvoDefsSystemMessageViewDataUnion is a union type.
#[derive(Debug, Clone)]
pub enum ConvoDefsSystemMessageViewDataUnion {
    ConvoDefsSystemMessageDataAddMember(Box<ConvoDefsSystemMessageDataAddMember>),
    ConvoDefsSystemMessageDataRemoveMember(Box<ConvoDefsSystemMessageDataRemoveMember>),
    ConvoDefsSystemMessageDataMemberJoin(Box<ConvoDefsSystemMessageDataMemberJoin>),
    ConvoDefsSystemMessageDataMemberLeave(Box<ConvoDefsSystemMessageDataMemberLeave>),
    ConvoDefsSystemMessageDataLockConvo(Box<ConvoDefsSystemMessageDataLockConvo>),
    ConvoDefsSystemMessageDataUnlockConvo(Box<ConvoDefsSystemMessageDataUnlockConvo>),
    ConvoDefsSystemMessageDataLockConvoPermanently(
        Box<ConvoDefsSystemMessageDataLockConvoPermanently>,
    ),
    ConvoDefsSystemMessageDataEditGroup(Box<ConvoDefsSystemMessageDataEditGroup>),
    ConvoDefsSystemMessageDataCreateJoinLink(Box<ConvoDefsSystemMessageDataCreateJoinLink>),
    ConvoDefsSystemMessageDataEditJoinLink(Box<ConvoDefsSystemMessageDataEditJoinLink>),
    ConvoDefsSystemMessageDataEnableJoinLink(Box<ConvoDefsSystemMessageDataEnableJoinLink>),
    ConvoDefsSystemMessageDataDisableJoinLink(Box<ConvoDefsSystemMessageDataDisableJoinLink>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ConvoDefsSystemMessageViewDataUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataAddMember(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataAddMember".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataRemoveMember(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataRemoveMember".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataMemberJoin(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataMemberJoin".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataMemberLeave(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataMemberLeave".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataLockConvo(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataLockConvo".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataUnlockConvo(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataUnlockConvo".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataLockConvoPermanently(
                inner,
            ) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataLockConvoPermanently"
                                .to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEditGroup(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataEditGroup".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataCreateJoinLink(
                inner,
            ) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataCreateJoinLink".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEditJoinLink(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataEditJoinLink".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEnableJoinLink(
                inner,
            ) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataEnableJoinLink".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataDisableJoinLink(
                inner,
            ) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "chat.bsky.convo.defs#systemMessageDataDisableJoinLink".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ConvoDefsSystemMessageViewDataUnion::Unknown(v) => {
                if let Some(ref j) = v.json {
                    j.serialize(serializer)
                } else {
                    Err(serde::ser::Error::custom(
                        "no JSON data for unknown union variant",
                    ))
                }
            }
        }
    }
}

impl<'de> serde::Deserialize<'de> for ConvoDefsSystemMessageViewDataUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#systemMessageDataAddMember" => {
                let inner: ConvoDefsSystemMessageDataAddMember =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataAddMember(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataRemoveMember" => {
                let inner: ConvoDefsSystemMessageDataRemoveMember =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataRemoveMember(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataMemberJoin" => {
                let inner: ConvoDefsSystemMessageDataMemberJoin =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataMemberJoin(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataMemberLeave" => {
                let inner: ConvoDefsSystemMessageDataMemberLeave =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataMemberLeave(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataLockConvo" => {
                let inner: ConvoDefsSystemMessageDataLockConvo =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataLockConvo(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataUnlockConvo" => {
                let inner: ConvoDefsSystemMessageDataUnlockConvo =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataUnlockConvo(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataLockConvoPermanently" => {
                let inner: ConvoDefsSystemMessageDataLockConvoPermanently =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataLockConvoPermanently(Box::new(inner)))
            }
            "chat.bsky.convo.defs#systemMessageDataEditGroup" => {
                let inner: ConvoDefsSystemMessageDataEditGroup =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEditGroup(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataCreateJoinLink" => {
                let inner: ConvoDefsSystemMessageDataCreateJoinLink =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataCreateJoinLink(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataEditJoinLink" => {
                let inner: ConvoDefsSystemMessageDataEditJoinLink =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEditJoinLink(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataEnableJoinLink" => {
                let inner: ConvoDefsSystemMessageDataEnableJoinLink =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEnableJoinLink(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataDisableJoinLink" => {
                let inner: ConvoDefsSystemMessageDataDisableJoinLink =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataDisableJoinLink(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(ConvoDefsSystemMessageViewDataUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ConvoDefsSystemMessageViewDataUnion {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        match self {
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataAddMember(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataRemoveMember(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataMemberJoin(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataMemberLeave(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataLockConvo(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataUnlockConvo(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataLockConvoPermanently(
                inner,
            ) => inner.encode_cbor(buf),
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEditGroup(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataCreateJoinLink(
                inner,
            ) => inner.encode_cbor(buf),
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEditJoinLink(inner) => {
                inner.encode_cbor(buf)
            }
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEnableJoinLink(
                inner,
            ) => inner.encode_cbor(buf),
            ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataDisableJoinLink(
                inner,
            ) => inner.encode_cbor(buf),
            ConvoDefsSystemMessageViewDataUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "chat.bsky.convo.defs#systemMessageDataAddMember" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataAddMember::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataAddMember(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataRemoveMember" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataRemoveMember::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataRemoveMember(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataMemberJoin" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataMemberJoin::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataMemberJoin(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataMemberLeave" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataMemberLeave::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataMemberLeave(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataLockConvo" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataLockConvo::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataLockConvo(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataUnlockConvo" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataUnlockConvo::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataUnlockConvo(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataLockConvoPermanently" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataLockConvoPermanently::decode_cbor(&mut dec)?;
                Ok(ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataLockConvoPermanently(Box::new(inner)))
            }
            "chat.bsky.convo.defs#systemMessageDataEditGroup" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataEditGroup::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEditGroup(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataCreateJoinLink" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataCreateJoinLink::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataCreateJoinLink(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataEditJoinLink" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataEditJoinLink::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEditJoinLink(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataEnableJoinLink" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataEnableJoinLink::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataEnableJoinLink(
                        Box::new(inner),
                    ),
                )
            }
            "chat.bsky.convo.defs#systemMessageDataDisableJoinLink" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ConvoDefsSystemMessageDataDisableJoinLink::decode_cbor(&mut dec)?;
                Ok(
                    ConvoDefsSystemMessageViewDataUnion::ConvoDefsSystemMessageDataDisableJoinLink(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(ConvoDefsSystemMessageViewDataUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ConvoDefsSystemMessageView {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let count = 4u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("id")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("rev")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.rev)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("data")?;
            self.data.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("sentAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.sent_at.as_str())?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.id)?;
                pairs.push(("id", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.rev)?;
                pairs.push(("rev", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.data.encode_cbor(&mut vbuf)?;
                pairs.push(("data", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.sent_at.as_str())?;
                pairs.push(("sentAt", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

    pub fn from_cbor(data: &[u8]) -> Result<Self, crate::cbor::CborError> {
        let mut decoder = crate::cbor::Decoder::new(data);
        let result = Self::decode_cbor(&mut decoder)?;
        if !decoder.is_empty() {
            return Err(crate::cbor::CborError::InvalidCbor("trailing data".into()));
        }
        Ok(result)
    }

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        let val = decoder.decode()?;
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => return Err(crate::cbor::CborError::InvalidCbor("expected map".into())),
        };

        let mut field_id: Option<String> = None;
        let mut field_rev: Option<String> = None;
        let mut field_data: Option<ConvoDefsSystemMessageViewDataUnion> = None;
        let mut field_sent_at: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "id" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "rev" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_rev = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "data" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_data = Some(ConvoDefsSystemMessageViewDataUnion::decode_cbor(&mut dec)?);
                }
                "sentAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_sent_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ConvoDefsSystemMessageView {
            id: field_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'id'".into())
            })?,
            rev: field_rev.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'rev'".into())
            })?,
            data: field_data.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'data'".into())
            })?,
            sent_at: field_sent_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'sentAt'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}