shrike 0.1.1

// Code generated by lexgen. DO NOT EDIT.

/// NotificationDefsActivitySubscription object from app.bsky.notification.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NotificationDefsActivitySubscription {
    pub post: bool,
    pub reply: 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 NotificationDefsActivitySubscription {
    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("post")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.post)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("reply")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.reply)?;
        } 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_bool(self.post)?;
                pairs.push(("post", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_bool(self.reply)?;
                pairs.push(("reply", 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<bool> = None;
        let mut field_reply: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "post" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_post = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "reply" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_reply = 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(NotificationDefsActivitySubscription {
            post: field_post.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'post'".into())
            })?,
            reply: field_reply.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'reply'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// NotificationDefsChatPreference object from app.bsky.notification.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NotificationDefsChatPreference {
    pub include: String,
    pub push: 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 NotificationDefsChatPreference {
    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("push")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.push)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("include")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.include)?;
        } 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_bool(self.push)?;
                pairs.push(("push", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.include)?;
                pairs.push(("include", 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_push: Option<bool> = None;
        let mut field_include: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "push" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_push = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "include" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_include = 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(NotificationDefsChatPreference {
            push: field_push.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'push'".into())
            })?,
            include: field_include.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'include'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// NotificationDefsFilterablePreference object from app.bsky.notification.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NotificationDefsFilterablePreference {
    pub include: String,
    pub list: bool,
    pub push: 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 NotificationDefsFilterablePreference {
    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("list")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.list)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("push")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.push)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("include")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.include)?;
        } 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_bool(self.list)?;
                pairs.push(("list", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_bool(self.push)?;
                pairs.push(("push", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.include)?;
                pairs.push(("include", 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_list: Option<bool> = None;
        let mut field_push: Option<bool> = None;
        let mut field_include: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "list" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_list = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "push" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_push = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "include" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_include = 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(NotificationDefsFilterablePreference {
            list: field_list.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'list'".into())
            })?,
            push: field_push.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'push'".into())
            })?,
            include: field_include.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'include'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// NotificationDefsPreference object from app.bsky.notification.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NotificationDefsPreference {
    pub list: bool,
    pub push: 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 NotificationDefsPreference {
    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("list")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.list)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("push")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.push)?;
        } 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_bool(self.list)?;
                pairs.push(("list", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_bool(self.push)?;
                pairs.push(("push", 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_list: Option<bool> = None;
        let mut field_push: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "list" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_list = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "push" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_push = 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(NotificationDefsPreference {
            list: field_list.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'list'".into())
            })?,
            push: field_push.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'push'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// NotificationDefsPreferences object from app.bsky.notification.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NotificationDefsPreferences {
    pub chat: NotificationDefsChatPreference,
    pub follow: NotificationDefsFilterablePreference,
    pub like: NotificationDefsFilterablePreference,
    pub like_via_repost: NotificationDefsFilterablePreference,
    pub mention: NotificationDefsFilterablePreference,
    pub quote: NotificationDefsFilterablePreference,
    pub reply: NotificationDefsFilterablePreference,
    pub repost: NotificationDefsFilterablePreference,
    pub repost_via_repost: NotificationDefsFilterablePreference,
    pub starterpack_joined: NotificationDefsPreference,
    pub subscribed_post: NotificationDefsPreference,
    pub unverified: NotificationDefsPreference,
    pub verified: NotificationDefsPreference,
    /// 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 NotificationDefsPreferences {
    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 = 13u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("chat")?;
            self.chat.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("like")?;
            self.like.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("quote")?;
            self.quote.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("reply")?;
            self.reply.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("follow")?;
            self.follow.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("repost")?;
            self.repost.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("mention")?;
            self.mention.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("verified")?;
            self.verified.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("unverified")?;
            self.unverified.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("likeViaRepost")?;
            self.like_via_repost.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("subscribedPost")?;
            self.subscribed_post.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("repostViaRepost")?;
            self.repost_via_repost.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("starterpackJoined")?;
            self.starterpack_joined.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.chat.encode_cbor(&mut vbuf)?;
                pairs.push(("chat", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.like.encode_cbor(&mut vbuf)?;
                pairs.push(("like", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.quote.encode_cbor(&mut vbuf)?;
                pairs.push(("quote", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.reply.encode_cbor(&mut vbuf)?;
                pairs.push(("reply", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.follow.encode_cbor(&mut vbuf)?;
                pairs.push(("follow", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.repost.encode_cbor(&mut vbuf)?;
                pairs.push(("repost", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.mention.encode_cbor(&mut vbuf)?;
                pairs.push(("mention", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.verified.encode_cbor(&mut vbuf)?;
                pairs.push(("verified", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.unverified.encode_cbor(&mut vbuf)?;
                pairs.push(("unverified", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.like_via_repost.encode_cbor(&mut vbuf)?;
                pairs.push(("likeViaRepost", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.subscribed_post.encode_cbor(&mut vbuf)?;
                pairs.push(("subscribedPost", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.repost_via_repost.encode_cbor(&mut vbuf)?;
                pairs.push(("repostViaRepost", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.starterpack_joined.encode_cbor(&mut vbuf)?;
                pairs.push(("starterpackJoined", 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_chat: Option<NotificationDefsChatPreference> = None;
        let mut field_like: Option<NotificationDefsFilterablePreference> = None;
        let mut field_quote: Option<NotificationDefsFilterablePreference> = None;
        let mut field_reply: Option<NotificationDefsFilterablePreference> = None;
        let mut field_follow: Option<NotificationDefsFilterablePreference> = None;
        let mut field_repost: Option<NotificationDefsFilterablePreference> = None;
        let mut field_mention: Option<NotificationDefsFilterablePreference> = None;
        let mut field_verified: Option<NotificationDefsPreference> = None;
        let mut field_unverified: Option<NotificationDefsPreference> = None;
        let mut field_like_via_repost: Option<NotificationDefsFilterablePreference> = None;
        let mut field_subscribed_post: Option<NotificationDefsPreference> = None;
        let mut field_repost_via_repost: Option<NotificationDefsFilterablePreference> = None;
        let mut field_starterpack_joined: Option<NotificationDefsPreference> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "chat" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_chat = Some(NotificationDefsChatPreference::decode_cbor(&mut dec)?);
                }
                "like" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_like = Some(NotificationDefsFilterablePreference::decode_cbor(&mut dec)?);
                }
                "quote" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_quote =
                        Some(NotificationDefsFilterablePreference::decode_cbor(&mut dec)?);
                }
                "reply" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_reply =
                        Some(NotificationDefsFilterablePreference::decode_cbor(&mut dec)?);
                }
                "follow" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_follow =
                        Some(NotificationDefsFilterablePreference::decode_cbor(&mut dec)?);
                }
                "repost" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_repost =
                        Some(NotificationDefsFilterablePreference::decode_cbor(&mut dec)?);
                }
                "mention" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_mention =
                        Some(NotificationDefsFilterablePreference::decode_cbor(&mut dec)?);
                }
                "verified" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_verified = Some(NotificationDefsPreference::decode_cbor(&mut dec)?);
                }
                "unverified" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_unverified = Some(NotificationDefsPreference::decode_cbor(&mut dec)?);
                }
                "likeViaRepost" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_like_via_repost =
                        Some(NotificationDefsFilterablePreference::decode_cbor(&mut dec)?);
                }
                "subscribedPost" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_subscribed_post =
                        Some(NotificationDefsPreference::decode_cbor(&mut dec)?);
                }
                "repostViaRepost" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_repost_via_repost =
                        Some(NotificationDefsFilterablePreference::decode_cbor(&mut dec)?);
                }
                "starterpackJoined" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_starterpack_joined =
                        Some(NotificationDefsPreference::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(NotificationDefsPreferences {
            chat: field_chat.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'chat'".into())
            })?,
            like: field_like.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'like'".into())
            })?,
            quote: field_quote.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'quote'".into())
            })?,
            reply: field_reply.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'reply'".into())
            })?,
            follow: field_follow.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'follow'".into())
            })?,
            repost: field_repost.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'repost'".into())
            })?,
            mention: field_mention.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'mention'".into())
            })?,
            verified: field_verified.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'verified'".into())
            })?,
            unverified: field_unverified.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'unverified'".into())
            })?,
            like_via_repost: field_like_via_repost.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'likeViaRepost'".into())
            })?,
            subscribed_post: field_subscribed_post.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'subscribedPost'".into(),
                )
            })?,
            repost_via_repost: field_repost_via_repost.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'repostViaRepost'".into(),
                )
            })?,
            starterpack_joined: field_starterpack_joined.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'starterpackJoined'".into(),
                )
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

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

/// NotificationDefsSubjectActivitySubscription — Object used to store activity subscription data in stash.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NotificationDefsSubjectActivitySubscription {
    pub activity_subscription: NotificationDefsActivitySubscription,
    pub subject: crate::syntax::Did,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl NotificationDefsSubjectActivitySubscription {
    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("subject")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.subject.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("activitySubscription")?;
            self.activity_subscription.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.subject.as_str())?;
                pairs.push(("subject", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.activity_subscription.encode_cbor(&mut vbuf)?;
                pairs.push(("activitySubscription", 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_subject: Option<crate::syntax::Did> = None;
        let mut field_activity_subscription: Option<NotificationDefsActivitySubscription> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "subject" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_subject = 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()));
                    }
                }
                "activitySubscription" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_activity_subscription =
                        Some(NotificationDefsActivitySubscription::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(NotificationDefsSubjectActivitySubscription {
            subject: field_subject.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'subject'".into())
            })?,
            activity_subscription: field_activity_subscription.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'activitySubscription'".into(),
                )
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}