shrike 0.1.0

// Code generated by lexgen. DO NOT EDIT.

/// FeedDefsBlockedAuthor object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsBlockedAuthor {
    pub did: crate::syntax::Did,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub viewer: Option<crate::api::app::bsky::ActorDefsViewerState>,
    /// 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 FeedDefsBlockedAuthor {
    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.viewer.is_some() {
                count += 1;
            }
            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())?;
            if self.viewer.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("viewer")?;
                if let Some(ref val) = self.viewer {
                    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.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            if self.viewer.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.viewer {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("viewer", 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_viewer: Option<crate::api::app::bsky::ActorDefsViewerState> = 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()));
                    }
                }
                "viewer" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_viewer = Some(crate::api::app::bsky::ActorDefsViewerState::decode_cbor(
                        &mut dec,
                    )?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

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

/// FeedDefsBlockedPost object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsBlockedPost {
    pub author: FeedDefsBlockedAuthor,
    pub blocked: bool,
    pub uri: crate::syntax::AtUri,
    /// 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 FeedDefsBlockedPost {
    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("uri")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.uri.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("author")?;
            self.author.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("blocked")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.blocked)?;
        } 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.uri.as_str())?;
                pairs.push(("uri", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.author.encode_cbor(&mut vbuf)?;
                pairs.push(("author", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_bool(self.blocked)?;
                pairs.push(("blocked", 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_uri: Option<crate::syntax::AtUri> = None;
        let mut field_author: Option<FeedDefsBlockedAuthor> = None;
        let mut field_blocked: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "uri" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_uri = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "author" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_author = Some(FeedDefsBlockedAuthor::decode_cbor(&mut dec)?);
                }
                "blocked" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_blocked = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(FeedDefsBlockedPost {
            uri: field_uri.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'uri'".into())
            })?,
            author: field_author.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'author'".into())
            })?,
            blocked: field_blocked.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'blocked'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// Token constant.
pub const FEED_DEFS_CLICKTHROUGH_AUTHOR: &str = "app.bsky.feed.defs#clickthroughAuthor";

/// Token constant.
pub const FEED_DEFS_CLICKTHROUGH_EMBED: &str = "app.bsky.feed.defs#clickthroughEmbed";

/// Token constant.
pub const FEED_DEFS_CLICKTHROUGH_ITEM: &str = "app.bsky.feed.defs#clickthroughItem";

/// Token constant.
pub const FEED_DEFS_CLICKTHROUGH_REPOSTER: &str = "app.bsky.feed.defs#clickthroughReposter";

/// Token constant.
pub const FEED_DEFS_CONTENT_MODE_UNSPECIFIED: &str = "app.bsky.feed.defs#contentModeUnspecified";

/// Token constant.
pub const FEED_DEFS_CONTENT_MODE_VIDEO: &str = "app.bsky.feed.defs#contentModeVideo";

/// FeedDefsFeedViewPost object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsFeedViewPost {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub feed_context: Option<String>,
    pub post: FeedDefsPostView,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<FeedDefsFeedViewPostReasonUnion>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reply: Option<FeedDefsReplyRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub req_id: 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>)>,
}

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

impl serde::Serialize for FeedDefsFeedViewPostReasonUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            FeedDefsFeedViewPostReasonUnion::FeedDefsReasonRepost(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.feed.defs#reasonRepost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsFeedViewPostReasonUnion::FeedDefsReasonPin(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.feed.defs#reasonPin".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsFeedViewPostReasonUnion::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 FeedDefsFeedViewPostReasonUnion {
    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.feed.defs#reasonRepost" => {
                let inner: FeedDefsReasonRepost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsFeedViewPostReasonUnion::FeedDefsReasonRepost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#reasonPin" => {
                let inner: FeedDefsReasonPin =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsFeedViewPostReasonUnion::FeedDefsReasonPin(
                    Box::new(inner),
                ))
            }
            _ => Ok(FeedDefsFeedViewPostReasonUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl FeedDefsFeedViewPostReasonUnion {
    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 {
            FeedDefsFeedViewPostReasonUnion::FeedDefsReasonRepost(inner) => inner.encode_cbor(buf),
            FeedDefsFeedViewPostReasonUnion::FeedDefsReasonPin(inner) => inner.encode_cbor(buf),
            FeedDefsFeedViewPostReasonUnion::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.feed.defs#reasonRepost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsReasonRepost::decode_cbor(&mut dec)?;
                Ok(FeedDefsFeedViewPostReasonUnion::FeedDefsReasonRepost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#reasonPin" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsReasonPin::decode_cbor(&mut dec)?;
                Ok(FeedDefsFeedViewPostReasonUnion::FeedDefsReasonPin(
                    Box::new(inner),
                ))
            }
            _ => Ok(FeedDefsFeedViewPostReasonUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl FeedDefsFeedViewPost {
    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.reply.is_some() {
                count += 1;
            }
            if self.req_id.is_some() {
                count += 1;
            }
            if self.reason.is_some() {
                count += 1;
            }
            if self.feed_context.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("post")?;
            self.post.encode_cbor(buf)?;
            if self.reply.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reply")?;
                if let Some(ref val) = self.reply {
                    val.encode_cbor(buf)?;
                }
            }
            if self.req_id.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reqId")?;
                if let Some(ref val) = self.req_id {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.reason.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reason")?;
                if let Some(ref val) = self.reason {
                    val.encode_cbor(buf)?;
                }
            }
            if self.feed_context.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("feedContext")?;
                if let Some(ref val) = self.feed_context {
                    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();
            {
                let mut vbuf = Vec::new();
                self.post.encode_cbor(&mut vbuf)?;
                pairs.push(("post", vbuf));
            }
            if self.reply.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.reply {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("reply", vbuf));
            }
            if self.req_id.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.req_id {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("reqId", vbuf));
            }
            if self.reason.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.reason {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("reason", vbuf));
            }
            if self.feed_context.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.feed_context {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("feedContext", 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_post: Option<FeedDefsPostView> = None;
        let mut field_reply: Option<FeedDefsReplyRef> = None;
        let mut field_req_id: Option<String> = None;
        let mut field_reason: Option<FeedDefsFeedViewPostReasonUnion> = None;
        let mut field_feed_context: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "post" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_post = Some(FeedDefsPostView::decode_cbor(&mut dec)?);
                }
                "reply" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_reply = Some(FeedDefsReplyRef::decode_cbor(&mut dec)?);
                }
                "reqId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_req_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "reason" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_reason = Some(FeedDefsFeedViewPostReasonUnion::decode_cbor(&mut dec)?);
                }
                "feedContext" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_feed_context = 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(FeedDefsFeedViewPost {
            post: field_post.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'post'".into())
            })?,
            reply: field_reply,
            req_id: field_req_id,
            reason: field_reason,
            feed_context: field_feed_context,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsGeneratorView object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsGeneratorView {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accepts_interactions: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub avatar: Option<String>,
    pub cid: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content_mode: Option<String>,
    pub creator: crate::api::app::bsky::ActorDefsProfileView,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub description_facets: Vec<crate::api::app::bsky::RichtextFacet>,
    pub did: crate::syntax::Did,
    pub display_name: String,
    pub indexed_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub labels: Vec<crate::api::com::atproto::LabelDefsLabel>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub like_count: Option<i64>,
    pub uri: crate::syntax::AtUri,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub viewer: Option<FeedDefsGeneratorViewerState>,
    /// 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 FeedDefsGeneratorView {
    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 = 6u64;
            if self.avatar.is_some() {
                count += 1;
            }
            if !self.labels.is_empty() {
                count += 1;
            }
            if self.viewer.is_some() {
                count += 1;
            }
            if self.like_count.is_some() {
                count += 1;
            }
            if self.content_mode.is_some() {
                count += 1;
            }
            if self.description.is_some() {
                count += 1;
            }
            if !self.description_facets.is_empty() {
                count += 1;
            }
            if self.accepts_interactions.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("cid")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.cid)?;
            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("uri")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.uri.as_str())?;
            if self.avatar.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("avatar")?;
                if let Some(ref val) = self.avatar {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if !self.labels.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("labels")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.labels.len() as u64)?;
                for item in &self.labels {
                    item.encode_cbor(buf)?;
                }
            }
            if self.viewer.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("viewer")?;
                if let Some(ref val) = self.viewer {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("creator")?;
            self.creator.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("indexedAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.indexed_at.as_str())?;
            if self.like_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("likeCount")?;
                if let Some(ref val) = self.like_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.content_mode.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("contentMode")?;
                if let Some(ref val) = self.content_mode {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.description.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("description")?;
                if let Some(ref val) = self.description {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("displayName")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.display_name)?;
            if !self.description_facets.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("descriptionFacets")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.description_facets.len() as u64)?;
                for item in &self.description_facets {
                    item.encode_cbor(buf)?;
                }
            }
            if self.accepts_interactions.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("acceptsInteractions")?;
                if let Some(ref val) = self.accepts_interactions {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*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.cid)?;
                pairs.push(("cid", vbuf));
            }
            {
                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.uri.as_str())?;
                pairs.push(("uri", vbuf));
            }
            if self.avatar.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.avatar {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("avatar", vbuf));
            }
            if !self.labels.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.labels.len() as u64)?;
                for item in &self.labels {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("labels", vbuf));
            }
            if self.viewer.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.viewer {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("viewer", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.creator.encode_cbor(&mut vbuf)?;
                pairs.push(("creator", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.indexed_at.as_str())?;
                pairs.push(("indexedAt", vbuf));
            }
            if self.like_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.like_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("likeCount", vbuf));
            }
            if self.content_mode.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.content_mode {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("contentMode", vbuf));
            }
            if self.description.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.description {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("description", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.display_name)?;
                pairs.push(("displayName", vbuf));
            }
            if !self.description_facets.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.description_facets.len() as u64)?;
                for item in &self.description_facets {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("descriptionFacets", vbuf));
            }
            if self.accepts_interactions.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.accepts_interactions {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("acceptsInteractions", 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_cid: Option<String> = None;
        let mut field_did: Option<crate::syntax::Did> = None;
        let mut field_uri: Option<crate::syntax::AtUri> = None;
        let mut field_avatar: Option<String> = None;
        let mut field_labels: Vec<crate::api::com::atproto::LabelDefsLabel> = Vec::new();
        let mut field_viewer: Option<FeedDefsGeneratorViewerState> = None;
        let mut field_creator: Option<crate::api::app::bsky::ActorDefsProfileView> = None;
        let mut field_indexed_at: Option<crate::syntax::Datetime> = None;
        let mut field_like_count: Option<i64> = None;
        let mut field_content_mode: Option<String> = None;
        let mut field_description: Option<String> = None;
        let mut field_display_name: Option<String> = None;
        let mut field_description_facets: Vec<crate::api::app::bsky::RichtextFacet> = Vec::new();
        let mut field_accepts_interactions: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "cid" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_cid = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "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()));
                    }
                }
                "uri" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_uri = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "avatar" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_avatar = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "labels" => {
                    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_labels.push(
                                crate::api::com::atproto::LabelDefsLabel::decode_cbor(&mut dec)?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "viewer" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_viewer = Some(FeedDefsGeneratorViewerState::decode_cbor(&mut dec)?);
                }
                "creator" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_creator = Some(crate::api::app::bsky::ActorDefsProfileView::decode_cbor(
                        &mut dec,
                    )?);
                }
                "indexedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_indexed_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()));
                    }
                }
                "likeCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_like_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_like_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "contentMode" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_content_mode = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "description" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_description = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "displayName" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_display_name = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "descriptionFacets" => {
                    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_description_facets
                                .push(crate::api::app::bsky::RichtextFacet::decode_cbor(&mut dec)?);
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "acceptsInteractions" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_accepts_interactions = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(FeedDefsGeneratorView {
            cid: field_cid.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'cid'".into())
            })?,
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            uri: field_uri.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'uri'".into())
            })?,
            avatar: field_avatar,
            labels: field_labels,
            viewer: field_viewer,
            creator: field_creator.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'creator'".into())
            })?,
            indexed_at: field_indexed_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'indexedAt'".into())
            })?,
            like_count: field_like_count,
            content_mode: field_content_mode,
            description: field_description,
            display_name: field_display_name.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'displayName'".into())
            })?,
            description_facets: field_description_facets,
            accepts_interactions: field_accepts_interactions,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsGeneratorViewerState object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsGeneratorViewerState {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub like: Option<crate::syntax::AtUri>,
    /// 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 FeedDefsGeneratorViewerState {
    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.like.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.like.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("like")?;
                if let Some(ref val) = self.like {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.like.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.like {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("like", 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_like: Option<crate::syntax::AtUri> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "like" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_like = Some(
                            crate::syntax::AtUri::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(FeedDefsGeneratorViewerState {
            like: field_like,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsInteraction object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsInteraction {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub event: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub feed_context: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub item: Option<crate::syntax::AtUri>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub req_id: 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 FeedDefsInteraction {
    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.item.is_some() {
                count += 1;
            }
            if self.event.is_some() {
                count += 1;
            }
            if self.req_id.is_some() {
                count += 1;
            }
            if self.feed_context.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.item.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("item")?;
                if let Some(ref val) = self.item {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.event.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("event")?;
                if let Some(ref val) = self.event {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.req_id.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reqId")?;
                if let Some(ref val) = self.req_id {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.feed_context.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("feedContext")?;
                if let Some(ref val) = self.feed_context {
                    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.item.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.item {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("item", vbuf));
            }
            if self.event.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.event {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("event", vbuf));
            }
            if self.req_id.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.req_id {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("reqId", vbuf));
            }
            if self.feed_context.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.feed_context {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("feedContext", 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_item: Option<crate::syntax::AtUri> = None;
        let mut field_event: Option<String> = None;
        let mut field_req_id: Option<String> = None;
        let mut field_feed_context: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "item" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_item = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "event" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_event = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "reqId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_req_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "feedContext" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_feed_context = 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(FeedDefsInteraction {
            item: field_item,
            event: field_event,
            req_id: field_req_id,
            feed_context: field_feed_context,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// Token constant.
pub const FEED_DEFS_INTERACTION_LIKE: &str = "app.bsky.feed.defs#interactionLike";

/// Token constant.
pub const FEED_DEFS_INTERACTION_QUOTE: &str = "app.bsky.feed.defs#interactionQuote";

/// Token constant.
pub const FEED_DEFS_INTERACTION_REPLY: &str = "app.bsky.feed.defs#interactionReply";

/// Token constant.
pub const FEED_DEFS_INTERACTION_REPOST: &str = "app.bsky.feed.defs#interactionRepost";

/// Token constant.
pub const FEED_DEFS_INTERACTION_SEEN: &str = "app.bsky.feed.defs#interactionSeen";

/// Token constant.
pub const FEED_DEFS_INTERACTION_SHARE: &str = "app.bsky.feed.defs#interactionShare";

/// FeedDefsNotFoundPost object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsNotFoundPost {
    pub not_found: bool,
    pub uri: crate::syntax::AtUri,
    /// 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 FeedDefsNotFoundPost {
    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("uri")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.uri.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("notFound")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.not_found)?;
        } 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.uri.as_str())?;
                pairs.push(("uri", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_bool(self.not_found)?;
                pairs.push(("notFound", 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_uri: Option<crate::syntax::AtUri> = None;
        let mut field_not_found: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

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

        Ok(FeedDefsNotFoundPost {
            uri: field_uri.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'uri'".into())
            })?,
            not_found: field_not_found.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'notFound'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsPostView object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsPostView {
    pub author: crate::api::app::bsky::ActorDefsProfileViewBasic,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bookmark_count: Option<i64>,
    pub cid: String,
    pub debug: serde_json::Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub embed: Option<FeedDefsPostViewEmbedUnion>,
    pub indexed_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub labels: Vec<crate::api::com::atproto::LabelDefsLabel>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub like_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quote_count: Option<i64>,
    pub record: serde_json::Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reply_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repost_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub threadgate: Option<FeedDefsThreadgateView>,
    pub uri: crate::syntax::AtUri,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub viewer: Option<FeedDefsViewerState>,
    /// 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>)>,
}

/// FeedDefsPostViewEmbedUnion is a union type.
#[derive(Debug, Clone)]
pub enum FeedDefsPostViewEmbedUnion {
    EmbedImagesView(Box<crate::api::app::bsky::EmbedImagesView>),
    EmbedVideoView(Box<crate::api::app::bsky::EmbedVideoView>),
    EmbedExternalView(Box<crate::api::app::bsky::EmbedExternalView>),
    EmbedRecordView(Box<crate::api::app::bsky::EmbedRecordView>),
    EmbedRecordWithMediaView(Box<crate::api::app::bsky::EmbedRecordWithMediaView>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for FeedDefsPostViewEmbedUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            FeedDefsPostViewEmbedUnion::EmbedImagesView(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.images#view".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsPostViewEmbedUnion::EmbedVideoView(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.video#view".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsPostViewEmbedUnion::EmbedExternalView(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.external#view".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsPostViewEmbedUnion::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)
            }
            FeedDefsPostViewEmbedUnion::EmbedRecordWithMediaView(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.recordWithMedia#view".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsPostViewEmbedUnion::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 FeedDefsPostViewEmbedUnion {
    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.images#view" => {
                let inner: crate::api::app::bsky::EmbedImagesView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedImagesView(Box::new(inner)))
            }
            "app.bsky.embed.video#view" => {
                let inner: crate::api::app::bsky::EmbedVideoView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedVideoView(Box::new(inner)))
            }
            "app.bsky.embed.external#view" => {
                let inner: crate::api::app::bsky::EmbedExternalView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedExternalView(Box::new(
                    inner,
                )))
            }
            "app.bsky.embed.record#view" => {
                let inner: crate::api::app::bsky::EmbedRecordView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedRecordView(Box::new(inner)))
            }
            "app.bsky.embed.recordWithMedia#view" => {
                let inner: crate::api::app::bsky::EmbedRecordWithMediaView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedRecordWithMediaView(
                    Box::new(inner),
                ))
            }
            _ => Ok(FeedDefsPostViewEmbedUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl FeedDefsPostViewEmbedUnion {
    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 {
            FeedDefsPostViewEmbedUnion::EmbedImagesView(inner) => inner.encode_cbor(buf),
            FeedDefsPostViewEmbedUnion::EmbedVideoView(inner) => inner.encode_cbor(buf),
            FeedDefsPostViewEmbedUnion::EmbedExternalView(inner) => inner.encode_cbor(buf),
            FeedDefsPostViewEmbedUnion::EmbedRecordView(inner) => inner.encode_cbor(buf),
            FeedDefsPostViewEmbedUnion::EmbedRecordWithMediaView(inner) => inner.encode_cbor(buf),
            FeedDefsPostViewEmbedUnion::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.images#view" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::app::bsky::EmbedImagesView::decode_cbor(&mut dec)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedImagesView(Box::new(inner)))
            }
            "app.bsky.embed.video#view" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::app::bsky::EmbedVideoView::decode_cbor(&mut dec)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedVideoView(Box::new(inner)))
            }
            "app.bsky.embed.external#view" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::app::bsky::EmbedExternalView::decode_cbor(&mut dec)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedExternalView(Box::new(
                    inner,
                )))
            }
            "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(FeedDefsPostViewEmbedUnion::EmbedRecordView(Box::new(inner)))
            }
            "app.bsky.embed.recordWithMedia#view" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::app::bsky::EmbedRecordWithMediaView::decode_cbor(&mut dec)?;
                Ok(FeedDefsPostViewEmbedUnion::EmbedRecordWithMediaView(
                    Box::new(inner),
                ))
            }
            _ => Ok(FeedDefsPostViewEmbedUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl FeedDefsPostView {
    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.embed.is_some() {
                count += 1;
            }
            if !self.labels.is_empty() {
                count += 1;
            }
            if self.viewer.is_some() {
                count += 1;
            }
            if self.like_count.is_some() {
                count += 1;
            }
            if self.quote_count.is_some() {
                count += 1;
            }
            if self.reply_count.is_some() {
                count += 1;
            }
            if self.threadgate.is_some() {
                count += 1;
            }
            if self.repost_count.is_some() {
                count += 1;
            }
            if self.bookmark_count.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("cid")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.cid)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("uri")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.uri.as_str())?;
            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)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("author")?;
            self.author.encode_cbor(buf)?;
            if !self.labels.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("labels")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.labels.len() as u64)?;
                for item in &self.labels {
                    item.encode_cbor(buf)?;
                }
            }
            if self.viewer.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("viewer")?;
                if let Some(ref val) = self.viewer {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("indexedAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.indexed_at.as_str())?;
            if self.like_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("likeCount")?;
                if let Some(ref val) = self.like_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.quote_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("quoteCount")?;
                if let Some(ref val) = self.quote_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.reply_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("replyCount")?;
                if let Some(ref val) = self.reply_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.threadgate.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("threadgate")?;
                if let Some(ref val) = self.threadgate {
                    val.encode_cbor(buf)?;
                }
            }
            if self.repost_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("repostCount")?;
                if let Some(ref val) = self.repost_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.bookmark_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("bookmarkCount")?;
                if let Some(ref val) = self.bookmark_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.cid)?;
                pairs.push(("cid", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.uri.as_str())?;
                pairs.push(("uri", 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));
            }
            {
                let mut vbuf = Vec::new();
                self.author.encode_cbor(&mut vbuf)?;
                pairs.push(("author", vbuf));
            }
            if !self.labels.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.labels.len() as u64)?;
                for item in &self.labels {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("labels", vbuf));
            }
            if self.viewer.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.viewer {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("viewer", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.indexed_at.as_str())?;
                pairs.push(("indexedAt", vbuf));
            }
            if self.like_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.like_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("likeCount", vbuf));
            }
            if self.quote_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.quote_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("quoteCount", vbuf));
            }
            if self.reply_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.reply_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("replyCount", vbuf));
            }
            if self.threadgate.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.threadgate {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("threadgate", vbuf));
            }
            if self.repost_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.repost_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("repostCount", vbuf));
            }
            if self.bookmark_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.bookmark_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("bookmarkCount", 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_cid: Option<String> = None;
        let mut field_uri: Option<crate::syntax::AtUri> = None;
        let mut field_embed: Option<FeedDefsPostViewEmbedUnion> = None;
        let mut field_author: Option<crate::api::app::bsky::ActorDefsProfileViewBasic> = None;
        let mut field_labels: Vec<crate::api::com::atproto::LabelDefsLabel> = Vec::new();
        let mut field_viewer: Option<FeedDefsViewerState> = None;
        let mut field_indexed_at: Option<crate::syntax::Datetime> = None;
        let mut field_like_count: Option<i64> = None;
        let mut field_quote_count: Option<i64> = None;
        let mut field_reply_count: Option<i64> = None;
        let mut field_threadgate: Option<FeedDefsThreadgateView> = None;
        let mut field_repost_count: Option<i64> = None;
        let mut field_bookmark_count: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "cid" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_cid = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "uri" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_uri = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.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(FeedDefsPostViewEmbedUnion::decode_cbor(&mut dec)?);
                }
                "author" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_author = Some(
                        crate::api::app::bsky::ActorDefsProfileViewBasic::decode_cbor(&mut dec)?,
                    );
                }
                "labels" => {
                    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_labels.push(
                                crate::api::com::atproto::LabelDefsLabel::decode_cbor(&mut dec)?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "viewer" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_viewer = Some(FeedDefsViewerState::decode_cbor(&mut dec)?);
                }
                "indexedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_indexed_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()));
                    }
                }
                "likeCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_like_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_like_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "quoteCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_quote_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_quote_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "replyCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_reply_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_reply_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "threadgate" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_threadgate = Some(FeedDefsThreadgateView::decode_cbor(&mut dec)?);
                }
                "repostCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_repost_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_repost_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "bookmarkCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_bookmark_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_bookmark_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(FeedDefsPostView {
            cid: field_cid.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'cid'".into())
            })?,
            uri: field_uri.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'uri'".into())
            })?,
            debug: Default::default(),
            embed: field_embed,
            author: field_author.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'author'".into())
            })?,
            labels: field_labels,
            record: Default::default(),
            viewer: field_viewer,
            indexed_at: field_indexed_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'indexedAt'".into())
            })?,
            like_count: field_like_count,
            quote_count: field_quote_count,
            reply_count: field_reply_count,
            threadgate: field_threadgate,
            repost_count: field_repost_count,
            bookmark_count: field_bookmark_count,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsReasonPin object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsReasonPin {
    /// 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 FeedDefsReasonPin {
    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(FeedDefsReasonPin {
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsReasonRepost object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsReasonRepost {
    pub by: crate::api::app::bsky::ActorDefsProfileViewBasic,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cid: Option<String>,
    pub indexed_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<crate::syntax::AtUri>,
    /// 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 FeedDefsReasonRepost {
    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.cid.is_some() {
                count += 1;
            }
            if self.uri.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("by")?;
            self.by.encode_cbor(buf)?;
            if self.cid.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("cid")?;
                if let Some(ref val) = self.cid {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.uri.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("uri")?;
                if let Some(ref val) = self.uri {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("indexedAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.indexed_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();
                self.by.encode_cbor(&mut vbuf)?;
                pairs.push(("by", vbuf));
            }
            if self.cid.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.cid {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("cid", vbuf));
            }
            if self.uri.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.uri {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("uri", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.indexed_at.as_str())?;
                pairs.push(("indexedAt", 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_by: Option<crate::api::app::bsky::ActorDefsProfileViewBasic> = None;
        let mut field_cid: Option<String> = None;
        let mut field_uri: Option<crate::syntax::AtUri> = None;
        let mut field_indexed_at: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "by" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_by = Some(
                        crate::api::app::bsky::ActorDefsProfileViewBasic::decode_cbor(&mut dec)?,
                    );
                }
                "cid" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_cid = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "uri" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_uri = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "indexedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_indexed_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(FeedDefsReasonRepost {
            by: field_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'by'".into())
            })?,
            cid: field_cid,
            uri: field_uri,
            indexed_at: field_indexed_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'indexedAt'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsReplyRef object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsReplyRef {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grandparent_author: Option<crate::api::app::bsky::ActorDefsProfileViewBasic>,
    pub parent: FeedDefsReplyRefParentUnion,
    pub root: FeedDefsReplyRefRootUnion,
    /// 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>)>,
}

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

impl serde::Serialize for FeedDefsReplyRefParentUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            FeedDefsReplyRefParentUnion::FeedDefsPostView(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.feed.defs#postView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsReplyRefParentUnion::FeedDefsNotFoundPost(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.feed.defs#notFoundPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsReplyRefParentUnion::FeedDefsBlockedPost(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.feed.defs#blockedPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsReplyRefParentUnion::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 FeedDefsReplyRefParentUnion {
    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.feed.defs#postView" => {
                let inner: FeedDefsPostView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsReplyRefParentUnion::FeedDefsPostView(Box::new(
                    inner,
                )))
            }
            "app.bsky.feed.defs#notFoundPost" => {
                let inner: FeedDefsNotFoundPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsReplyRefParentUnion::FeedDefsNotFoundPost(Box::new(
                    inner,
                )))
            }
            "app.bsky.feed.defs#blockedPost" => {
                let inner: FeedDefsBlockedPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsReplyRefParentUnion::FeedDefsBlockedPost(Box::new(
                    inner,
                )))
            }
            _ => Ok(FeedDefsReplyRefParentUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl FeedDefsReplyRefParentUnion {
    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 {
            FeedDefsReplyRefParentUnion::FeedDefsPostView(inner) => inner.encode_cbor(buf),
            FeedDefsReplyRefParentUnion::FeedDefsNotFoundPost(inner) => inner.encode_cbor(buf),
            FeedDefsReplyRefParentUnion::FeedDefsBlockedPost(inner) => inner.encode_cbor(buf),
            FeedDefsReplyRefParentUnion::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.feed.defs#postView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsPostView::decode_cbor(&mut dec)?;
                Ok(FeedDefsReplyRefParentUnion::FeedDefsPostView(Box::new(
                    inner,
                )))
            }
            "app.bsky.feed.defs#notFoundPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsNotFoundPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsReplyRefParentUnion::FeedDefsNotFoundPost(Box::new(
                    inner,
                )))
            }
            "app.bsky.feed.defs#blockedPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsBlockedPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsReplyRefParentUnion::FeedDefsBlockedPost(Box::new(
                    inner,
                )))
            }
            _ => Ok(FeedDefsReplyRefParentUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

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

impl serde::Serialize for FeedDefsReplyRefRootUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            FeedDefsReplyRefRootUnion::FeedDefsPostView(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.feed.defs#postView".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsReplyRefRootUnion::FeedDefsNotFoundPost(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.feed.defs#notFoundPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsReplyRefRootUnion::FeedDefsBlockedPost(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.feed.defs#blockedPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsReplyRefRootUnion::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 FeedDefsReplyRefRootUnion {
    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.feed.defs#postView" => {
                let inner: FeedDefsPostView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsReplyRefRootUnion::FeedDefsPostView(Box::new(inner)))
            }
            "app.bsky.feed.defs#notFoundPost" => {
                let inner: FeedDefsNotFoundPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsReplyRefRootUnion::FeedDefsNotFoundPost(Box::new(
                    inner,
                )))
            }
            "app.bsky.feed.defs#blockedPost" => {
                let inner: FeedDefsBlockedPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsReplyRefRootUnion::FeedDefsBlockedPost(Box::new(
                    inner,
                )))
            }
            _ => Ok(FeedDefsReplyRefRootUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl FeedDefsReplyRefRootUnion {
    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 {
            FeedDefsReplyRefRootUnion::FeedDefsPostView(inner) => inner.encode_cbor(buf),
            FeedDefsReplyRefRootUnion::FeedDefsNotFoundPost(inner) => inner.encode_cbor(buf),
            FeedDefsReplyRefRootUnion::FeedDefsBlockedPost(inner) => inner.encode_cbor(buf),
            FeedDefsReplyRefRootUnion::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.feed.defs#postView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsPostView::decode_cbor(&mut dec)?;
                Ok(FeedDefsReplyRefRootUnion::FeedDefsPostView(Box::new(inner)))
            }
            "app.bsky.feed.defs#notFoundPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsNotFoundPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsReplyRefRootUnion::FeedDefsNotFoundPost(Box::new(
                    inner,
                )))
            }
            "app.bsky.feed.defs#blockedPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsBlockedPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsReplyRefRootUnion::FeedDefsBlockedPost(Box::new(
                    inner,
                )))
            }
            _ => Ok(FeedDefsReplyRefRootUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl FeedDefsReplyRef {
    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.grandparent_author.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("root")?;
            self.root.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("parent")?;
            self.parent.encode_cbor(buf)?;
            if self.grandparent_author.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("grandparentAuthor")?;
                if let Some(ref val) = self.grandparent_author {
                    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();
                self.root.encode_cbor(&mut vbuf)?;
                pairs.push(("root", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.parent.encode_cbor(&mut vbuf)?;
                pairs.push(("parent", vbuf));
            }
            if self.grandparent_author.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.grandparent_author {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("grandparentAuthor", 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_root: Option<FeedDefsReplyRefRootUnion> = None;
        let mut field_parent: Option<FeedDefsReplyRefParentUnion> = None;
        let mut field_grandparent_author: Option<crate::api::app::bsky::ActorDefsProfileViewBasic> =
            None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "root" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_root = Some(FeedDefsReplyRefRootUnion::decode_cbor(&mut dec)?);
                }
                "parent" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_parent = Some(FeedDefsReplyRefParentUnion::decode_cbor(&mut dec)?);
                }
                "grandparentAuthor" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_grandparent_author = Some(
                        crate::api::app::bsky::ActorDefsProfileViewBasic::decode_cbor(&mut dec)?,
                    );
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(FeedDefsReplyRef {
            root: field_root.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'root'".into())
            })?,
            parent: field_parent.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'parent'".into())
            })?,
            grandparent_author: field_grandparent_author,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// Token constant.
pub const FEED_DEFS_REQUEST_LESS: &str = "app.bsky.feed.defs#requestLess";

/// Token constant.
pub const FEED_DEFS_REQUEST_MORE: &str = "app.bsky.feed.defs#requestMore";

/// FeedDefsSkeletonFeedPost object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsSkeletonFeedPost {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub feed_context: Option<String>,
    pub post: crate::syntax::AtUri,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<FeedDefsSkeletonFeedPostReasonUnion>,
    /// 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>)>,
}

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

impl serde::Serialize for FeedDefsSkeletonFeedPostReasonUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            FeedDefsSkeletonFeedPostReasonUnion::FeedDefsSkeletonReasonRepost(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.feed.defs#skeletonReasonRepost".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsSkeletonFeedPostReasonUnion::FeedDefsSkeletonReasonPin(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.feed.defs#skeletonReasonPin".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsSkeletonFeedPostReasonUnion::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 FeedDefsSkeletonFeedPostReasonUnion {
    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.feed.defs#skeletonReasonRepost" => {
                let inner: FeedDefsSkeletonReasonRepost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    FeedDefsSkeletonFeedPostReasonUnion::FeedDefsSkeletonReasonRepost(Box::new(
                        inner,
                    )),
                )
            }
            "app.bsky.feed.defs#skeletonReasonPin" => {
                let inner: FeedDefsSkeletonReasonPin =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsSkeletonFeedPostReasonUnion::FeedDefsSkeletonReasonPin(Box::new(inner)))
            }
            _ => Ok(FeedDefsSkeletonFeedPostReasonUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl FeedDefsSkeletonFeedPostReasonUnion {
    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 {
            FeedDefsSkeletonFeedPostReasonUnion::FeedDefsSkeletonReasonRepost(inner) => {
                inner.encode_cbor(buf)
            }
            FeedDefsSkeletonFeedPostReasonUnion::FeedDefsSkeletonReasonPin(inner) => {
                inner.encode_cbor(buf)
            }
            FeedDefsSkeletonFeedPostReasonUnion::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.feed.defs#skeletonReasonRepost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsSkeletonReasonRepost::decode_cbor(&mut dec)?;
                Ok(
                    FeedDefsSkeletonFeedPostReasonUnion::FeedDefsSkeletonReasonRepost(Box::new(
                        inner,
                    )),
                )
            }
            "app.bsky.feed.defs#skeletonReasonPin" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsSkeletonReasonPin::decode_cbor(&mut dec)?;
                Ok(FeedDefsSkeletonFeedPostReasonUnion::FeedDefsSkeletonReasonPin(Box::new(inner)))
            }
            _ => Ok(FeedDefsSkeletonFeedPostReasonUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl FeedDefsSkeletonFeedPost {
    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.reason.is_some() {
                count += 1;
            }
            if self.feed_context.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("post")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.post.as_str())?;
            if self.reason.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reason")?;
                if let Some(ref val) = self.reason {
                    val.encode_cbor(buf)?;
                }
            }
            if self.feed_context.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("feedContext")?;
                if let Some(ref val) = self.feed_context {
                    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();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.post.as_str())?;
                pairs.push(("post", vbuf));
            }
            if self.reason.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.reason {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("reason", vbuf));
            }
            if self.feed_context.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.feed_context {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("feedContext", 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_post: Option<crate::syntax::AtUri> = None;
        let mut field_reason: Option<FeedDefsSkeletonFeedPostReasonUnion> = None;
        let mut field_feed_context: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "post" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_post = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "reason" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_reason =
                        Some(FeedDefsSkeletonFeedPostReasonUnion::decode_cbor(&mut dec)?);
                }
                "feedContext" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_feed_context = 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(FeedDefsSkeletonFeedPost {
            post: field_post.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'post'".into())
            })?,
            reason: field_reason,
            feed_context: field_feed_context,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsSkeletonReasonPin object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsSkeletonReasonPin {
    /// 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 FeedDefsSkeletonReasonPin {
    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(FeedDefsSkeletonReasonPin {
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsSkeletonReasonRepost object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsSkeletonReasonRepost {
    pub repost: crate::syntax::AtUri,
    /// 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 FeedDefsSkeletonReasonRepost {
    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("repost")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.repost.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.repost.as_str())?;
                pairs.push(("repost", 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_repost: Option<crate::syntax::AtUri> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "repost" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_repost = Some(
                            crate::syntax::AtUri::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(FeedDefsSkeletonReasonRepost {
            repost: field_repost.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'repost'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsThreadContext — Metadata about this post within the context of the thread it is in.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsThreadContext {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub root_author_like: Option<crate::syntax::AtUri>,
    /// 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 FeedDefsThreadContext {
    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.root_author_like.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.root_author_like.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("rootAuthorLike")?;
                if let Some(ref val) = self.root_author_like {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.root_author_like.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.root_author_like {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("rootAuthorLike", 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_root_author_like: Option<crate::syntax::AtUri> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "rootAuthorLike" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_root_author_like = Some(
                            crate::syntax::AtUri::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(FeedDefsThreadContext {
            root_author_like: field_root_author_like,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsThreadViewPost object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsThreadViewPost {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent: Option<FeedDefsThreadViewPostParentUnion>,
    pub post: FeedDefsPostView,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub replies: Vec<FeedDefsThreadViewPostRepliesUnion>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thread_context: Option<FeedDefsThreadContext>,
    /// 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>)>,
}

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

impl serde::Serialize for FeedDefsThreadViewPostParentUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            FeedDefsThreadViewPostParentUnion::FeedDefsThreadViewPost(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.feed.defs#threadViewPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsThreadViewPostParentUnion::FeedDefsNotFoundPost(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.feed.defs#notFoundPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsThreadViewPostParentUnion::FeedDefsBlockedPost(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.feed.defs#blockedPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsThreadViewPostParentUnion::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 FeedDefsThreadViewPostParentUnion {
    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.feed.defs#threadViewPost" => {
                let inner: FeedDefsThreadViewPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsThreadViewPostParentUnion::FeedDefsThreadViewPost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#notFoundPost" => {
                let inner: FeedDefsNotFoundPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsThreadViewPostParentUnion::FeedDefsNotFoundPost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#blockedPost" => {
                let inner: FeedDefsBlockedPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsThreadViewPostParentUnion::FeedDefsBlockedPost(
                    Box::new(inner),
                ))
            }
            _ => Ok(FeedDefsThreadViewPostParentUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl FeedDefsThreadViewPostParentUnion {
    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 {
            FeedDefsThreadViewPostParentUnion::FeedDefsThreadViewPost(inner) => {
                inner.encode_cbor(buf)
            }
            FeedDefsThreadViewPostParentUnion::FeedDefsNotFoundPost(inner) => {
                inner.encode_cbor(buf)
            }
            FeedDefsThreadViewPostParentUnion::FeedDefsBlockedPost(inner) => inner.encode_cbor(buf),
            FeedDefsThreadViewPostParentUnion::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.feed.defs#threadViewPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsThreadViewPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsThreadViewPostParentUnion::FeedDefsThreadViewPost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#notFoundPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsNotFoundPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsThreadViewPostParentUnion::FeedDefsNotFoundPost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#blockedPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsBlockedPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsThreadViewPostParentUnion::FeedDefsBlockedPost(
                    Box::new(inner),
                ))
            }
            _ => Ok(FeedDefsThreadViewPostParentUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

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

impl serde::Serialize for FeedDefsThreadViewPostRepliesUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            FeedDefsThreadViewPostRepliesUnion::FeedDefsThreadViewPost(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.feed.defs#threadViewPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsThreadViewPostRepliesUnion::FeedDefsNotFoundPost(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.feed.defs#notFoundPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsThreadViewPostRepliesUnion::FeedDefsBlockedPost(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.feed.defs#blockedPost".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            FeedDefsThreadViewPostRepliesUnion::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 FeedDefsThreadViewPostRepliesUnion {
    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.feed.defs#threadViewPost" => {
                let inner: FeedDefsThreadViewPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsThreadViewPostRepliesUnion::FeedDefsThreadViewPost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#notFoundPost" => {
                let inner: FeedDefsNotFoundPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsThreadViewPostRepliesUnion::FeedDefsNotFoundPost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#blockedPost" => {
                let inner: FeedDefsBlockedPost =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(FeedDefsThreadViewPostRepliesUnion::FeedDefsBlockedPost(
                    Box::new(inner),
                ))
            }
            _ => Ok(FeedDefsThreadViewPostRepliesUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl FeedDefsThreadViewPostRepliesUnion {
    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 {
            FeedDefsThreadViewPostRepliesUnion::FeedDefsThreadViewPost(inner) => {
                inner.encode_cbor(buf)
            }
            FeedDefsThreadViewPostRepliesUnion::FeedDefsNotFoundPost(inner) => {
                inner.encode_cbor(buf)
            }
            FeedDefsThreadViewPostRepliesUnion::FeedDefsBlockedPost(inner) => {
                inner.encode_cbor(buf)
            }
            FeedDefsThreadViewPostRepliesUnion::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.feed.defs#threadViewPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsThreadViewPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsThreadViewPostRepliesUnion::FeedDefsThreadViewPost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#notFoundPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsNotFoundPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsThreadViewPostRepliesUnion::FeedDefsNotFoundPost(
                    Box::new(inner),
                ))
            }
            "app.bsky.feed.defs#blockedPost" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = FeedDefsBlockedPost::decode_cbor(&mut dec)?;
                Ok(FeedDefsThreadViewPostRepliesUnion::FeedDefsBlockedPost(
                    Box::new(inner),
                ))
            }
            _ => Ok(FeedDefsThreadViewPostRepliesUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl FeedDefsThreadViewPost {
    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.parent.is_some() {
                count += 1;
            }
            if !self.replies.is_empty() {
                count += 1;
            }
            if self.thread_context.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("post")?;
            self.post.encode_cbor(buf)?;
            if self.parent.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("parent")?;
                if let Some(ref val) = self.parent {
                    val.encode_cbor(buf)?;
                }
            }
            if !self.replies.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("replies")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.replies.len() as u64)?;
                for item in &self.replies {
                    item.encode_cbor(buf)?;
                }
            }
            if self.thread_context.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("threadContext")?;
                if let Some(ref val) = self.thread_context {
                    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();
                self.post.encode_cbor(&mut vbuf)?;
                pairs.push(("post", vbuf));
            }
            if self.parent.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.parent {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("parent", vbuf));
            }
            if !self.replies.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.replies.len() as u64)?;
                for item in &self.replies {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("replies", vbuf));
            }
            if self.thread_context.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.thread_context {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("threadContext", 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_post: Option<FeedDefsPostView> = None;
        let mut field_parent: Option<FeedDefsThreadViewPostParentUnion> = None;
        let mut field_replies: Vec<FeedDefsThreadViewPostRepliesUnion> = Vec::new();
        let mut field_thread_context: Option<FeedDefsThreadContext> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "post" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_post = Some(FeedDefsPostView::decode_cbor(&mut dec)?);
                }
                "parent" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_parent = Some(FeedDefsThreadViewPostParentUnion::decode_cbor(&mut dec)?);
                }
                "replies" => {
                    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_replies
                                .push(FeedDefsThreadViewPostRepliesUnion::decode_cbor(&mut dec)?);
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "threadContext" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_thread_context = Some(FeedDefsThreadContext::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(FeedDefsThreadViewPost {
            post: field_post.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'post'".into())
            })?,
            parent: field_parent,
            replies: field_replies,
            thread_context: field_thread_context,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsThreadgateView object from app.bsky.feed.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsThreadgateView {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cid: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub lists: Vec<crate::api::app::bsky::GraphDefsListViewBasic>,
    pub record: serde_json::Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<crate::syntax::AtUri>,
    /// 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 FeedDefsThreadgateView {
    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.cid.is_some() {
                count += 1;
            }
            if self.uri.is_some() {
                count += 1;
            }
            if !self.lists.is_empty() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.cid.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("cid")?;
                if let Some(ref val) = self.cid {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.uri.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("uri")?;
                if let Some(ref val) = self.uri {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if !self.lists.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lists")?;
                crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.lists.len() as u64)?;
                for item in &self.lists {
                    item.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.cid.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.cid {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("cid", vbuf));
            }
            if self.uri.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.uri {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("uri", vbuf));
            }
            if !self.lists.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_array_header(self.lists.len() as u64)?;
                for item in &self.lists {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("lists", 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_cid: Option<String> = None;
        let mut field_uri: Option<crate::syntax::AtUri> = None;
        let mut field_lists: Vec<crate::api::app::bsky::GraphDefsListViewBasic> = Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "cid" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_cid = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "uri" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_uri = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "lists" => {
                    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_lists.push(
                                crate::api::app::bsky::GraphDefsListViewBasic::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(FeedDefsThreadgateView {
            cid: field_cid,
            uri: field_uri,
            lists: field_lists,
            record: Default::default(),
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// FeedDefsViewerState — Metadata about the requesting account's relationship with the subject content. Only has meaningfu...
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedDefsViewerState {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bookmarked: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub embedding_disabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub like: Option<crate::syntax::AtUri>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pinned: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reply_disabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repost: Option<crate::syntax::AtUri>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thread_muted: Option<bool>,
    /// 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 FeedDefsViewerState {
    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.like.is_some() {
                count += 1;
            }
            if self.pinned.is_some() {
                count += 1;
            }
            if self.repost.is_some() {
                count += 1;
            }
            if self.bookmarked.is_some() {
                count += 1;
            }
            if self.thread_muted.is_some() {
                count += 1;
            }
            if self.reply_disabled.is_some() {
                count += 1;
            }
            if self.embedding_disabled.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.like.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("like")?;
                if let Some(ref val) = self.like {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.pinned.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("pinned")?;
                if let Some(ref val) = self.pinned {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            if self.repost.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("repost")?;
                if let Some(ref val) = self.repost {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.bookmarked.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("bookmarked")?;
                if let Some(ref val) = self.bookmarked {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            if self.thread_muted.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("threadMuted")?;
                if let Some(ref val) = self.thread_muted {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            if self.reply_disabled.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("replyDisabled")?;
                if let Some(ref val) = self.reply_disabled {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            if self.embedding_disabled.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("embeddingDisabled")?;
                if let Some(ref val) = self.embedding_disabled {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.like.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.like {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("like", vbuf));
            }
            if self.pinned.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.pinned {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("pinned", vbuf));
            }
            if self.repost.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.repost {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("repost", vbuf));
            }
            if self.bookmarked.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.bookmarked {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("bookmarked", vbuf));
            }
            if self.thread_muted.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.thread_muted {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("threadMuted", vbuf));
            }
            if self.reply_disabled.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.reply_disabled {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("replyDisabled", vbuf));
            }
            if self.embedding_disabled.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.embedding_disabled {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("embeddingDisabled", 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_like: Option<crate::syntax::AtUri> = None;
        let mut field_pinned: Option<bool> = None;
        let mut field_repost: Option<crate::syntax::AtUri> = None;
        let mut field_bookmarked: Option<bool> = None;
        let mut field_thread_muted: Option<bool> = None;
        let mut field_reply_disabled: Option<bool> = None;
        let mut field_embedding_disabled: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "like" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_like = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "pinned" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_pinned = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "repost" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_repost = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "bookmarked" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_bookmarked = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "threadMuted" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_thread_muted = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "replyDisabled" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_reply_disabled = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "embeddingDisabled" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_embedding_disabled = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(FeedDefsViewerState {
            like: field_like,
            pinned: field_pinned,
            repost: field_repost,
            bookmarked: field_bookmarked,
            thread_muted: field_thread_muted,
            reply_disabled: field_reply_disabled,
            embedding_disabled: field_embedding_disabled,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}