shrike 0.1.1

// Code generated by lexgen. DO NOT EDIT.

/// ModerationDefsAccountEvent — Logs account status related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsAccountEvent {
    /// Indicates that the account has a repository which can be fetched from the host that emitted this event.
    pub active: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    pub timestamp: crate::syntax::Datetime,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsAccountEvent {
    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.status.is_some() {
                count += 1;
            }
            if self.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("active")?;
            crate::cbor::Encoder::new(&mut *buf).encode_bool(self.active)?;
            if self.status.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("status")?;
                if let Some(ref val) = self.status {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("timestamp")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.timestamp.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_bool(self.active)?;
                pairs.push(("active", vbuf));
            }
            if self.status.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.status {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("status", vbuf));
            }
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.timestamp.as_str())?;
                pairs.push(("timestamp", 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_active: Option<bool> = None;
        let mut field_status: Option<String> = None;
        let mut field_comment: Option<String> = None;
        let mut field_timestamp: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "active" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_active = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "status" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_status = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "timestamp" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_timestamp = 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(ModerationDefsAccountEvent {
            active: field_active.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'active'".into())
            })?,
            status: field_status,
            comment: field_comment,
            timestamp: field_timestamp.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'timestamp'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsAccountHosting object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsAccountHosting {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deactivated_at: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted_at: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reactivated_at: Option<crate::syntax::Datetime>,
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<crate::syntax::Datetime>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsAccountHosting {
    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.created_at.is_some() {
                count += 1;
            }
            if self.deleted_at.is_some() {
                count += 1;
            }
            if self.updated_at.is_some() {
                count += 1;
            }
            if self.deactivated_at.is_some() {
                count += 1;
            }
            if self.reactivated_at.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("status")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.status)?;
            if self.created_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
                if let Some(ref val) = self.created_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.deleted_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("deletedAt")?;
                if let Some(ref val) = self.deleted_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.updated_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("updatedAt")?;
                if let Some(ref val) = self.updated_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.deactivated_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("deactivatedAt")?;
                if let Some(ref val) = self.deactivated_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.reactivated_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reactivatedAt")?;
                if let Some(ref val) = self.reactivated_at {
                    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();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.status)?;
                pairs.push(("status", vbuf));
            }
            if self.created_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.created_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("createdAt", vbuf));
            }
            if self.deleted_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.deleted_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("deletedAt", vbuf));
            }
            if self.updated_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.updated_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("updatedAt", vbuf));
            }
            if self.deactivated_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.deactivated_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("deactivatedAt", vbuf));
            }
            if self.reactivated_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.reactivated_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("reactivatedAt", 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_status: Option<String> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_deleted_at: Option<crate::syntax::Datetime> = None;
        let mut field_updated_at: Option<crate::syntax::Datetime> = None;
        let mut field_deactivated_at: Option<crate::syntax::Datetime> = None;
        let mut field_reactivated_at: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "status" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_status = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "deletedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_deleted_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()));
                    }
                }
                "updatedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_updated_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()));
                    }
                }
                "deactivatedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_deactivated_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()));
                    }
                }
                "reactivatedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_reactivated_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(ModerationDefsAccountHosting {
            status: field_status.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'status'".into())
            })?,
            created_at: field_created_at,
            deleted_at: field_deleted_at,
            updated_at: field_updated_at,
            deactivated_at: field_deactivated_at,
            reactivated_at: field_reactivated_at,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsAccountStats — Statistics about a particular account subject
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsAccountStats {
    /// Total number of appeals against a moderation action on the account
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub appeal_count: Option<i64>,
    /// Number of times the account was escalated
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub escalate_count: Option<i64>,
    /// Total number of reports on the account
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub report_count: Option<i64>,
    /// Number of times the account was suspended
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub suspend_count: Option<i64>,
    /// Number of times the account was taken down
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub takedown_count: Option<i64>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsAccountStats {
    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.appeal_count.is_some() {
                count += 1;
            }
            if self.report_count.is_some() {
                count += 1;
            }
            if self.suspend_count.is_some() {
                count += 1;
            }
            if self.escalate_count.is_some() {
                count += 1;
            }
            if self.takedown_count.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.appeal_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("appealCount")?;
                if let Some(ref val) = self.appeal_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.report_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reportCount")?;
                if let Some(ref val) = self.report_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.suspend_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("suspendCount")?;
                if let Some(ref val) = self.suspend_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.escalate_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("escalateCount")?;
                if let Some(ref val) = self.escalate_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.takedown_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("takedownCount")?;
                if let Some(ref val) = self.takedown_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();
            if self.appeal_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.appeal_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("appealCount", vbuf));
            }
            if self.report_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.report_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("reportCount", vbuf));
            }
            if self.suspend_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.suspend_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("suspendCount", vbuf));
            }
            if self.escalate_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.escalate_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("escalateCount", vbuf));
            }
            if self.takedown_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.takedown_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("takedownCount", 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_appeal_count: Option<i64> = None;
        let mut field_report_count: Option<i64> = None;
        let mut field_suspend_count: Option<i64> = None;
        let mut field_escalate_count: Option<i64> = None;
        let mut field_takedown_count: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "appealCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_appeal_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_appeal_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "reportCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_report_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_report_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "suspendCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_suspend_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_suspend_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "escalateCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_escalate_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_escalate_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "takedownCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_takedown_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_takedown_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(ModerationDefsAccountStats {
            appeal_count: field_appeal_count,
            report_count: field_report_count,
            suspend_count: field_suspend_count,
            escalate_count: field_escalate_count,
            takedown_count: field_takedown_count,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsAccountStrike — Strike information for an account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsAccountStrike {
    /// Current number of active strikes (excluding expired strikes)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_strike_count: Option<i64>,
    /// Timestamp of the first strike received
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub first_strike_at: Option<crate::syntax::Datetime>,
    /// Timestamp of the most recent strike received
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_strike_at: Option<crate::syntax::Datetime>,
    /// Total number of strikes ever received (including expired strikes)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_strike_count: Option<i64>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsAccountStrike {
    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.last_strike_at.is_some() {
                count += 1;
            }
            if self.first_strike_at.is_some() {
                count += 1;
            }
            if self.total_strike_count.is_some() {
                count += 1;
            }
            if self.active_strike_count.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.last_strike_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastStrikeAt")?;
                if let Some(ref val) = self.last_strike_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.first_strike_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("firstStrikeAt")?;
                if let Some(ref val) = self.first_strike_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.total_strike_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("totalStrikeCount")?;
                if let Some(ref val) = self.total_strike_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.active_strike_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("activeStrikeCount")?;
                if let Some(ref val) = self.active_strike_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();
            if self.last_strike_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_strike_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("lastStrikeAt", vbuf));
            }
            if self.first_strike_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.first_strike_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("firstStrikeAt", vbuf));
            }
            if self.total_strike_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.total_strike_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("totalStrikeCount", vbuf));
            }
            if self.active_strike_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.active_strike_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("activeStrikeCount", 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_last_strike_at: Option<crate::syntax::Datetime> = None;
        let mut field_first_strike_at: Option<crate::syntax::Datetime> = None;
        let mut field_total_strike_count: Option<i64> = None;
        let mut field_active_strike_count: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "lastStrikeAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_last_strike_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()));
                    }
                }
                "firstStrikeAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_first_strike_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()));
                    }
                }
                "totalStrikeCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_total_strike_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_total_strike_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "activeStrikeCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_active_strike_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_active_strike_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(ModerationDefsAccountStrike {
            last_strike_at: field_last_strike_at,
            first_strike_at: field_first_strike_at,
            total_strike_count: field_total_strike_count,
            active_strike_count: field_active_strike_count,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsAgeAssuranceEvent — Age assurance info coming directly from users. Only works on DID subjects.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsAgeAssuranceEvent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub access: Option<crate::api::app::bsky::AgeassuranceDefsAccess>,
    /// The unique identifier for this instance of the age assurance flow, in UUID format.
    pub attempt_id: String,
    /// The IP address used when completing the AA flow.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub complete_ip: Option<String>,
    /// The user agent used when completing the AA flow.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub complete_ua: Option<String>,
    /// The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub country_code: Option<String>,
    /// The date and time of this write operation.
    pub created_at: crate::syntax::Datetime,
    /// The IP address used when initiating the AA flow.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub init_ip: Option<String>,
    /// The user agent used when initiating the AA flow.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub init_ua: Option<String>,
    /// The ISO 3166-2 region code provided when beginning the Age Assurance flow.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region_code: Option<String>,
    /// The status of the Age Assurance process.
    pub status: 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 ModerationDefsAgeAssuranceEvent {
    pub fn to_cbor(&self) -> Result<Vec<u8>, crate::cbor::CborError> {
        let mut buf = Vec::new();
        self.encode_cbor(&mut buf)?;
        Ok(buf)
    }

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 3u64;
            if self.access.is_some() {
                count += 1;
            }
            if self.init_ip.is_some() {
                count += 1;
            }
            if self.init_ua.is_some() {
                count += 1;
            }
            if self.complete_ip.is_some() {
                count += 1;
            }
            if self.complete_ua.is_some() {
                count += 1;
            }
            if self.region_code.is_some() {
                count += 1;
            }
            if self.country_code.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.access.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("access")?;
                if let Some(ref val) = self.access {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.init_ip.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("initIp")?;
                if let Some(ref val) = self.init_ip {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.init_ua.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("initUa")?;
                if let Some(ref val) = self.init_ua {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("status")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.status)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("attemptId")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.attempt_id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
            if self.complete_ip.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("completeIp")?;
                if let Some(ref val) = self.complete_ip {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.complete_ua.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("completeUa")?;
                if let Some(ref val) = self.complete_ua {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.region_code.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("regionCode")?;
                if let Some(ref val) = self.region_code {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.country_code.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("countryCode")?;
                if let Some(ref val) = self.country_code {
                    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.access.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.access {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("access", vbuf));
            }
            if self.init_ip.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.init_ip {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("initIp", vbuf));
            }
            if self.init_ua.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.init_ua {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("initUa", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.status)?;
                pairs.push(("status", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.attempt_id)?;
                pairs.push(("attemptId", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            if self.complete_ip.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.complete_ip {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("completeIp", vbuf));
            }
            if self.complete_ua.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.complete_ua {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("completeUa", vbuf));
            }
            if self.region_code.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.region_code {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("regionCode", vbuf));
            }
            if self.country_code.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.country_code {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("countryCode", 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_access: Option<crate::api::app::bsky::AgeassuranceDefsAccess> = None;
        let mut field_init_ip: Option<String> = None;
        let mut field_init_ua: Option<String> = None;
        let mut field_status: Option<String> = None;
        let mut field_attempt_id: Option<String> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_complete_ip: Option<String> = None;
        let mut field_complete_ua: Option<String> = None;
        let mut field_region_code: Option<String> = None;
        let mut field_country_code: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "access" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_access = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "initIp" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_init_ip = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "initUa" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_init_ua = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "status" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_status = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "attemptId" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_attempt_id = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "completeIp" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_complete_ip = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "completeUa" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_complete_ua = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "regionCode" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_region_code = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "countryCode" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_country_code = 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(ModerationDefsAgeAssuranceEvent {
            access: field_access,
            init_ip: field_init_ip,
            init_ua: field_init_ua,
            status: field_status.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'status'".into())
            })?,
            attempt_id: field_attempt_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'attemptId'".into())
            })?,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            complete_ip: field_complete_ip,
            complete_ua: field_complete_ua,
            region_code: field_region_code,
            country_code: field_country_code,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsAgeAssuranceOverrideEvent — Age assurance status override by moderators. Only works on DID subjects.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsAgeAssuranceOverrideEvent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub access: Option<crate::api::app::bsky::AgeassuranceDefsAccess>,
    /// Comment describing the reason for the override.
    pub comment: String,
    /// The status to be set for the user decided by a moderator, overriding whatever value the user had previously. Use reset to default to original state.
    pub status: 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 ModerationDefsAgeAssuranceOverrideEvent {
    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.access.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.access.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("access")?;
                if let Some(ref val) = self.access {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("status")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.status)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.comment)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.access.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.access {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("access", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.status)?;
                pairs.push(("status", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.comment)?;
                pairs.push(("comment", 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_access: Option<crate::api::app::bsky::AgeassuranceDefsAccess> = None;
        let mut field_status: Option<String> = None;
        let mut field_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "access" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_access = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "status" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_status = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsAgeAssuranceOverrideEvent {
            access: field_access,
            status: field_status.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'status'".into())
            })?,
            comment: field_comment.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'comment'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsAgeAssurancePurgeEvent — Purges all age assurance events for the subject. Only works on DID subjects. Moderator-only.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsAgeAssurancePurgeEvent {
    /// Comment describing the reason for the purge.
    pub comment: 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 ModerationDefsAgeAssurancePurgeEvent {
    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("comment")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.comment)?;
        } 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.comment)?;
                pairs.push(("comment", 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_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

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

/// ModerationDefsBlobView object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsBlobView {
    pub cid: String,
    pub created_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<ModerationDefsBlobViewDetailsUnion>,
    pub mime_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub moderation: Option<ModerationDefsModeration>,
    pub size: i64,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

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

impl serde::Serialize for ModerationDefsBlobViewDetailsUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ModerationDefsBlobViewDetailsUnion::ModerationDefsImageDetails(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(
                            "tools.ozone.moderation.defs#imageDetails".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsBlobViewDetailsUnion::ModerationDefsVideoDetails(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(
                            "tools.ozone.moderation.defs#videoDetails".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsBlobViewDetailsUnion::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 ModerationDefsBlobViewDetailsUnion {
    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 {
            "tools.ozone.moderation.defs#imageDetails" => {
                let inner: ModerationDefsImageDetails =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsBlobViewDetailsUnion::ModerationDefsImageDetails(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#videoDetails" => {
                let inner: ModerationDefsVideoDetails =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsBlobViewDetailsUnion::ModerationDefsVideoDetails(Box::new(inner)))
            }
            _ => Ok(ModerationDefsBlobViewDetailsUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ModerationDefsBlobViewDetailsUnion {
    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 {
            ModerationDefsBlobViewDetailsUnion::ModerationDefsImageDetails(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsBlobViewDetailsUnion::ModerationDefsVideoDetails(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsBlobViewDetailsUnion::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 {
            "tools.ozone.moderation.defs#imageDetails" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsImageDetails::decode_cbor(&mut dec)?;
                Ok(ModerationDefsBlobViewDetailsUnion::ModerationDefsImageDetails(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#videoDetails" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsVideoDetails::decode_cbor(&mut dec)?;
                Ok(ModerationDefsBlobViewDetailsUnion::ModerationDefsVideoDetails(Box::new(inner)))
            }
            _ => Ok(ModerationDefsBlobViewDetailsUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ModerationDefsBlobView {
    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.details.is_some() {
                count += 1;
            }
            if self.moderation.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("size")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.size)?;
            if self.details.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("details")?;
                if let Some(ref val) = self.details {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("mimeType")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.mime_type)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
            if self.moderation.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("moderation")?;
                if let Some(ref val) = self.moderation {
                    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.cid)?;
                pairs.push(("cid", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.size)?;
                pairs.push(("size", vbuf));
            }
            if self.details.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.details {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("details", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.mime_type)?;
                pairs.push(("mimeType", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            if self.moderation.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.moderation {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("moderation", 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_size: Option<i64> = None;
        let mut field_details: Option<ModerationDefsBlobViewDetailsUnion> = None;
        let mut field_mime_type: Option<String> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_moderation: Option<ModerationDefsModeration> = 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()));
                    }
                }
                "size" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_size = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_size = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "details" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_details =
                        Some(ModerationDefsBlobViewDetailsUnion::decode_cbor(&mut dec)?);
                }
                "mimeType" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_mime_type = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "moderation" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_moderation = Some(ModerationDefsModeration::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ModerationDefsBlobView {
            cid: field_cid.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'cid'".into())
            })?,
            size: field_size.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'size'".into())
            })?,
            details: field_details,
            mime_type: field_mime_type.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'mimeType'".into())
            })?,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            moderation: field_moderation,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsCancelScheduledTakedownEvent — Logs cancellation of a scheduled takedown action for an account.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsCancelScheduledTakedownEvent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: 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 ModerationDefsCancelScheduledTakedownEvent {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsCancelScheduledTakedownEvent {
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsIdentityEvent — Logs identity related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsIdentityEvent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub handle: Option<crate::syntax::Handle>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pds_host: Option<String>,
    pub timestamp: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tombstone: 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 ModerationDefsIdentityEvent {
    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.handle.is_some() {
                count += 1;
            }
            if self.comment.is_some() {
                count += 1;
            }
            if self.pds_host.is_some() {
                count += 1;
            }
            if self.tombstone.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.handle.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("handle")?;
                if let Some(ref val) = self.handle {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.pds_host.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("pdsHost")?;
                if let Some(ref val) = self.pds_host {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("timestamp")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.timestamp.as_str())?;
            if self.tombstone.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("tombstone")?;
                if let Some(ref val) = self.tombstone {
                    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.handle.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.handle {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("handle", vbuf));
            }
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            if self.pds_host.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.pds_host {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("pdsHost", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.timestamp.as_str())?;
                pairs.push(("timestamp", vbuf));
            }
            if self.tombstone.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.tombstone {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("tombstone", 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_handle: Option<crate::syntax::Handle> = None;
        let mut field_comment: Option<String> = None;
        let mut field_pds_host: Option<String> = None;
        let mut field_timestamp: Option<crate::syntax::Datetime> = None;
        let mut field_tombstone: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "handle" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_handle = Some(
                            crate::syntax::Handle::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "pdsHost" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_pds_host = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "timestamp" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_timestamp = 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()));
                    }
                }
                "tombstone" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_tombstone = 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(ModerationDefsIdentityEvent {
            handle: field_handle,
            comment: field_comment,
            pds_host: field_pds_host,
            timestamp: field_timestamp.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'timestamp'".into())
            })?,
            tombstone: field_tombstone,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsImageDetails object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsImageDetails {
    pub height: i64,
    pub width: i64,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsImageDetails {
    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("width")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.width)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("height")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.height)?;
        } 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_i64(self.width)?;
                pairs.push(("width", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.height)?;
                pairs.push(("height", 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_width: Option<i64> = None;
        let mut field_height: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "width" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_width = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_width = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "height" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_height = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_height = 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(ModerationDefsImageDetails {
            width: field_width.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'width'".into())
            })?,
            height: field_height.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'height'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventAcknowledge object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventAcknowledge {
    /// If true, all other reports on content authored by this account will be resolved (acknowledged).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub acknowledge_account_subjects: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: 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 ModerationDefsModEventAcknowledge {
    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.comment.is_some() {
                count += 1;
            }
            if self.acknowledge_account_subjects.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.acknowledge_account_subjects.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("acknowledgeAccountSubjects")?;
                if let Some(ref val) = self.acknowledge_account_subjects {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            if self.acknowledge_account_subjects.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.acknowledge_account_subjects {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("acknowledgeAccountSubjects", 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_comment: Option<String> = None;
        let mut field_acknowledge_account_subjects: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "acknowledgeAccountSubjects" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_acknowledge_account_subjects = 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(ModerationDefsModEventAcknowledge {
            comment: field_comment,
            acknowledge_account_subjects: field_acknowledge_account_subjects,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventComment — Add a comment to a subject. An empty comment will clear any previously set sticky comment.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventComment {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// Make the comment persistent on the subject
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sticky: 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 ModerationDefsModEventComment {
    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.sticky.is_some() {
                count += 1;
            }
            if self.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.sticky.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("sticky")?;
                if let Some(ref val) = self.sticky {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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.sticky.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.sticky {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("sticky", vbuf));
            }
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_sticky: Option<bool> = None;
        let mut field_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "sticky" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_sticky = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsModEventComment {
            sticky: field_sticky,
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventDivert — Divert a record's blobs to a 3rd party service for further scanning/tagging
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventDivert {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: 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 ModerationDefsModEventDivert {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsModEventDivert {
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventEmail — Keep a log of outgoing email to a user
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventEmail {
    /// Additional comment about the outgoing comm.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// The content of the email sent to the user.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    /// Indicates whether the email was successfully delivered to the user's inbox.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub is_delivered: Option<bool>,
    /// Names/Keywords of the policies that necessitated the email.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub policies: Vec<String>,
    /// Severity level of the violation. Normally 'sev-1' that adds strike on repeat offense
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub severity_level: Option<String>,
    /// Number of strikes to assign to the user for this violation. Normally 0 as an indicator of a warning and only added as a strike on a repeat offense.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strike_count: Option<i64>,
    /// When the strike should expire. If not provided, the strike never expires.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strike_expires_at: Option<crate::syntax::Datetime>,
    /// The subject line of the email sent to the user.
    pub subject_line: 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 ModerationDefsModEventEmail {
    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.comment.is_some() {
                count += 1;
            }
            if self.content.is_some() {
                count += 1;
            }
            if !self.policies.is_empty() {
                count += 1;
            }
            if self.is_delivered.is_some() {
                count += 1;
            }
            if self.strike_count.is_some() {
                count += 1;
            }
            if self.severity_level.is_some() {
                count += 1;
            }
            if self.strike_expires_at.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.content.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("content")?;
                if let Some(ref val) = self.content {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if !self.policies.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("policies")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.policies.len() as u64)?;
                for item in &self.policies {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
                }
            }
            if self.is_delivered.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("isDelivered")?;
                if let Some(ref val) = self.is_delivered {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            if self.strike_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("strikeCount")?;
                if let Some(ref val) = self.strike_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("subjectLine")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.subject_line)?;
            if self.severity_level.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("severityLevel")?;
                if let Some(ref val) = self.severity_level {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.strike_expires_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("strikeExpiresAt")?;
                if let Some(ref val) = self.strike_expires_at {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            if self.content.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.content {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("content", vbuf));
            }
            if !self.policies.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.policies.len() as u64)?;
                for item in &self.policies {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("policies", vbuf));
            }
            if self.is_delivered.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.is_delivered {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("isDelivered", vbuf));
            }
            if self.strike_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.strike_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("strikeCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.subject_line)?;
                pairs.push(("subjectLine", vbuf));
            }
            if self.severity_level.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.severity_level {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("severityLevel", vbuf));
            }
            if self.strike_expires_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.strike_expires_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("strikeExpiresAt", 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_comment: Option<String> = None;
        let mut field_content: Option<String> = None;
        let mut field_policies: Vec<String> = Vec::new();
        let mut field_is_delivered: Option<bool> = None;
        let mut field_strike_count: Option<i64> = None;
        let mut field_subject_line: Option<String> = None;
        let mut field_severity_level: Option<String> = None;
        let mut field_strike_expires_at: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "content" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_content = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "policies" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_policies.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "isDelivered" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_is_delivered = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "strikeCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_strike_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_strike_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "subjectLine" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_subject_line = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "severityLevel" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_severity_level = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "strikeExpiresAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_strike_expires_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(ModerationDefsModEventEmail {
            comment: field_comment,
            content: field_content,
            policies: field_policies,
            is_delivered: field_is_delivered,
            strike_count: field_strike_count,
            subject_line: field_subject_line.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'subjectLine'".into())
            })?,
            severity_level: field_severity_level,
            strike_expires_at: field_strike_expires_at,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventEscalate object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventEscalate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: 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 ModerationDefsModEventEscalate {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsModEventEscalate {
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventLabel — Apply/Negate labels on a subject
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventLabel {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub create_label_vals: Vec<String>,
    /// Indicates how long the label will remain on the subject. Only applies on labels that are being added.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_in_hours: Option<i64>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub negate_label_vals: Vec<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 ModerationDefsModEventLabel {
    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.comment.is_some() {
                count += 1;
            }
            if self.duration_in_hours.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("createLabelVals")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.create_label_vals.len() as u64)?;
            for item in &self.create_label_vals {
                crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
            }
            if self.duration_in_hours.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("durationInHours")?;
                if let Some(ref val) = self.duration_in_hours {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("negateLabelVals")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.negate_label_vals.len() as u64)?;
            for item in &self.negate_label_vals {
                crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.create_label_vals.len() as u64)?;
                for item in &self.create_label_vals {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("createLabelVals", vbuf));
            }
            if self.duration_in_hours.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.duration_in_hours {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("durationInHours", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.negate_label_vals.len() as u64)?;
                for item in &self.negate_label_vals {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("negateLabelVals", 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_comment: Option<String> = None;
        let mut field_create_label_vals: Vec<String> = Vec::new();
        let mut field_duration_in_hours: Option<i64> = None;
        let mut field_negate_label_vals: Vec<String> = Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createLabelVals" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_create_label_vals.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "durationInHours" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_duration_in_hours = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_duration_in_hours = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "negateLabelVals" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_negate_label_vals.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } 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(ModerationDefsModEventLabel {
            comment: field_comment,
            create_label_vals: field_create_label_vals,
            duration_in_hours: field_duration_in_hours,
            negate_label_vals: field_negate_label_vals,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventMute — Mute incoming reports on a subject
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventMute {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// Indicates how long the subject should remain muted.
    pub duration_in_hours: i64,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsModEventMute {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("durationInHours")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.duration_in_hours)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.duration_in_hours)?;
                pairs.push(("durationInHours", 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_comment: Option<String> = None;
        let mut field_duration_in_hours: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "durationInHours" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_duration_in_hours = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_duration_in_hours = 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(ModerationDefsModEventMute {
            comment: field_comment,
            duration_in_hours: field_duration_in_hours.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'durationInHours'".into(),
                )
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventMuteReporter — Mute incoming reports from an account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventMuteReporter {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// Indicates how long the account should remain muted. Falsy value here means a permanent mute.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_in_hours: Option<i64>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsModEventMuteReporter {
    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.comment.is_some() {
                count += 1;
            }
            if self.duration_in_hours.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.duration_in_hours.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("durationInHours")?;
                if let Some(ref val) = self.duration_in_hours {
                    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();
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            if self.duration_in_hours.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.duration_in_hours {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("durationInHours", 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_comment: Option<String> = None;
        let mut field_duration_in_hours: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "durationInHours" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_duration_in_hours = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_duration_in_hours = 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(ModerationDefsModEventMuteReporter {
            comment: field_comment,
            duration_in_hours: field_duration_in_hours,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventPriorityScore — Set priority score of the subject. Higher score means higher priority.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventPriorityScore {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    pub score: i64,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsModEventPriorityScore {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("score")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.score)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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_i64(self.score)?;
                pairs.push(("score", vbuf));
            }
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_score: Option<i64> = None;
        let mut field_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "score" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_score = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_score = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsModEventPriorityScore {
            score: field_score.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'score'".into())
            })?,
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventReport — Report a subject
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventReport {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// Set to true if the reporter was muted from reporting at the time of the event. These reports won't impact the reviewState of the subject.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub is_reporter_muted: Option<bool>,
    pub report_type: crate::api::com::atproto::ModerationDefsReasonType,
    /// 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 ModerationDefsModEventReport {
    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.comment.is_some() {
                count += 1;
            }
            if self.is_reporter_muted.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("reportType")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.report_type)?;
            if self.is_reporter_muted.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("isReporterMuted")?;
                if let Some(ref val) = self.is_reporter_muted {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.report_type)?;
                pairs.push(("reportType", vbuf));
            }
            if self.is_reporter_muted.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.is_reporter_muted {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("isReporterMuted", 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_comment: Option<String> = None;
        let mut field_report_type: Option<crate::api::com::atproto::ModerationDefsReasonType> =
            None;
        let mut field_is_reporter_muted: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "reportType" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_report_type = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "isReporterMuted" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_is_reporter_muted = 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(ModerationDefsModEventReport {
            comment: field_comment,
            report_type: field_report_type.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'reportType'".into())
            })?,
            is_reporter_muted: field_is_reporter_muted,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventResolveAppeal — Resolve appeal on a subject
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventResolveAppeal {
    /// Describe resolution.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: 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 ModerationDefsModEventResolveAppeal {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsModEventResolveAppeal {
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventReverseTakedown — Revert take down action on a subject
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventReverseTakedown {
    /// Describe reasoning behind the reversal.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// Names/Keywords of the policy infraction for which takedown is being reversed.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub policies: Vec<String>,
    /// Severity level of the violation. Usually set from the last policy infraction's severity.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub severity_level: Option<String>,
    /// Number of strikes to subtract from the user's strike count. Usually set from the last policy infraction's severity.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strike_count: Option<i64>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsModEventReverseTakedown {
    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.comment.is_some() {
                count += 1;
            }
            if !self.policies.is_empty() {
                count += 1;
            }
            if self.strike_count.is_some() {
                count += 1;
            }
            if self.severity_level.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if !self.policies.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("policies")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.policies.len() as u64)?;
                for item in &self.policies {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
                }
            }
            if self.strike_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("strikeCount")?;
                if let Some(ref val) = self.strike_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.severity_level.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("severityLevel")?;
                if let Some(ref val) = self.severity_level {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            if !self.policies.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.policies.len() as u64)?;
                for item in &self.policies {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("policies", vbuf));
            }
            if self.strike_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.strike_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("strikeCount", vbuf));
            }
            if self.severity_level.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.severity_level {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("severityLevel", 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_comment: Option<String> = None;
        let mut field_policies: Vec<String> = Vec::new();
        let mut field_strike_count: Option<i64> = None;
        let mut field_severity_level: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "policies" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_policies.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "strikeCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_strike_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_strike_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "severityLevel" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_severity_level = 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(ModerationDefsModEventReverseTakedown {
            comment: field_comment,
            policies: field_policies,
            strike_count: field_strike_count,
            severity_level: field_severity_level,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventTag — Add/Remove a tag on a subject
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventTag {
    /// Tags to be added to the subject. If already exists, won't be duplicated.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub add: Vec<String>,
    /// Additional comment about added/removed tags.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub remove: Vec<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 ModerationDefsModEventTag {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("add")?;
            crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.add.len() as u64)?;
            for item in &self.add {
                crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("remove")?;
            crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.remove.len() as u64)?;
            for item in &self.remove {
                crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
            }
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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_array_header(self.add.len() as u64)?;
                for item in &self.add {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("add", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.remove.len() as u64)?;
                for item in &self.remove {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("remove", vbuf));
            }
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_add: Vec<String> = Vec::new();
        let mut field_remove: Vec<String> = Vec::new();
        let mut field_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "add" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_add.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "remove" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_remove.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsModEventTag {
            add: field_add,
            remove: field_remove,
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventTakedown — Take down a subject permanently or temporarily
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventTakedown {
    /// If true, all other reports on content authored by this account will be resolved (acknowledged).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub acknowledge_account_subjects: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// Indicates how long the takedown should be in effect before automatically expiring.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_in_hours: Option<i64>,
    /// Names/Keywords of the policies that drove the decision.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub policies: Vec<String>,
    /// Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub severity_level: Option<String>,
    /// Number of strikes to assign to the user for this violation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strike_count: Option<i64>,
    /// When the strike should expire. If not provided, the strike never expires.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strike_expires_at: Option<crate::syntax::Datetime>,
    /// List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub target_services: Vec<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 ModerationDefsModEventTakedown {
    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.comment.is_some() {
                count += 1;
            }
            if !self.policies.is_empty() {
                count += 1;
            }
            if self.strike_count.is_some() {
                count += 1;
            }
            if self.severity_level.is_some() {
                count += 1;
            }
            if !self.target_services.is_empty() {
                count += 1;
            }
            if self.duration_in_hours.is_some() {
                count += 1;
            }
            if self.strike_expires_at.is_some() {
                count += 1;
            }
            if self.acknowledge_account_subjects.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if !self.policies.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("policies")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.policies.len() as u64)?;
                for item in &self.policies {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
                }
            }
            if self.strike_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("strikeCount")?;
                if let Some(ref val) = self.strike_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.severity_level.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("severityLevel")?;
                if let Some(ref val) = self.severity_level {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if !self.target_services.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("targetServices")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.target_services.len() as u64)?;
                for item in &self.target_services {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
                }
            }
            if self.duration_in_hours.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("durationInHours")?;
                if let Some(ref val) = self.duration_in_hours {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.strike_expires_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("strikeExpiresAt")?;
                if let Some(ref val) = self.strike_expires_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.acknowledge_account_subjects.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("acknowledgeAccountSubjects")?;
                if let Some(ref val) = self.acknowledge_account_subjects {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            if !self.policies.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.policies.len() as u64)?;
                for item in &self.policies {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("policies", vbuf));
            }
            if self.strike_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.strike_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("strikeCount", vbuf));
            }
            if self.severity_level.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.severity_level {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("severityLevel", vbuf));
            }
            if !self.target_services.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.target_services.len() as u64)?;
                for item in &self.target_services {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("targetServices", vbuf));
            }
            if self.duration_in_hours.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.duration_in_hours {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("durationInHours", vbuf));
            }
            if self.strike_expires_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.strike_expires_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("strikeExpiresAt", vbuf));
            }
            if self.acknowledge_account_subjects.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.acknowledge_account_subjects {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("acknowledgeAccountSubjects", 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_comment: Option<String> = None;
        let mut field_policies: Vec<String> = Vec::new();
        let mut field_strike_count: Option<i64> = None;
        let mut field_severity_level: Option<String> = None;
        let mut field_target_services: Vec<String> = Vec::new();
        let mut field_duration_in_hours: Option<i64> = None;
        let mut field_strike_expires_at: Option<crate::syntax::Datetime> = None;
        let mut field_acknowledge_account_subjects: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "policies" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_policies.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "strikeCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_strike_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_strike_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "severityLevel" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_severity_level = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "targetServices" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_target_services.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "durationInHours" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_duration_in_hours = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_duration_in_hours = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "strikeExpiresAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_strike_expires_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()));
                    }
                }
                "acknowledgeAccountSubjects" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_acknowledge_account_subjects = 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(ModerationDefsModEventTakedown {
            comment: field_comment,
            policies: field_policies,
            strike_count: field_strike_count,
            severity_level: field_severity_level,
            target_services: field_target_services,
            duration_in_hours: field_duration_in_hours,
            strike_expires_at: field_strike_expires_at,
            acknowledge_account_subjects: field_acknowledge_account_subjects,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventUnmute — Unmute action on a subject
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventUnmute {
    /// Describe reasoning behind the reversal.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: 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 ModerationDefsModEventUnmute {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsModEventUnmute {
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventUnmuteReporter — Unmute incoming reports from an account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventUnmuteReporter {
    /// Describe reasoning behind the reversal.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: 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 ModerationDefsModEventUnmuteReporter {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", 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_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = 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(ModerationDefsModEventUnmuteReporter {
            comment: field_comment,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventView object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventView {
    pub created_at: crate::syntax::Datetime,
    pub created_by: crate::syntax::Did,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub creator_handle: Option<String>,
    pub event: ModerationDefsModEventViewEventUnion,
    pub id: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mod_tool: Option<ModerationDefsModTool>,
    pub subject: ModerationDefsModEventViewSubjectUnion,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub subject_blob_cids: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subject_handle: 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>)>,
}

/// ModerationDefsModEventViewEventUnion is a union type.
#[derive(Debug, Clone)]
pub enum ModerationDefsModEventViewEventUnion {
    ModerationDefsModEventTakedown(Box<ModerationDefsModEventTakedown>),
    ModerationDefsModEventReverseTakedown(Box<ModerationDefsModEventReverseTakedown>),
    ModerationDefsModEventComment(Box<ModerationDefsModEventComment>),
    ModerationDefsModEventReport(Box<ModerationDefsModEventReport>),
    ModerationDefsModEventLabel(Box<ModerationDefsModEventLabel>),
    ModerationDefsModEventAcknowledge(Box<ModerationDefsModEventAcknowledge>),
    ModerationDefsModEventEscalate(Box<ModerationDefsModEventEscalate>),
    ModerationDefsModEventMute(Box<ModerationDefsModEventMute>),
    ModerationDefsModEventUnmute(Box<ModerationDefsModEventUnmute>),
    ModerationDefsModEventMuteReporter(Box<ModerationDefsModEventMuteReporter>),
    ModerationDefsModEventUnmuteReporter(Box<ModerationDefsModEventUnmuteReporter>),
    ModerationDefsModEventEmail(Box<ModerationDefsModEventEmail>),
    ModerationDefsModEventResolveAppeal(Box<ModerationDefsModEventResolveAppeal>),
    ModerationDefsModEventDivert(Box<ModerationDefsModEventDivert>),
    ModerationDefsModEventTag(Box<ModerationDefsModEventTag>),
    ModerationDefsAccountEvent(Box<ModerationDefsAccountEvent>),
    ModerationDefsIdentityEvent(Box<ModerationDefsIdentityEvent>),
    ModerationDefsRecordEvent(Box<ModerationDefsRecordEvent>),
    ModerationDefsModEventPriorityScore(Box<ModerationDefsModEventPriorityScore>),
    ModerationDefsAgeAssuranceEvent(Box<ModerationDefsAgeAssuranceEvent>),
    ModerationDefsAgeAssuranceOverrideEvent(Box<ModerationDefsAgeAssuranceOverrideEvent>),
    ModerationDefsAgeAssurancePurgeEvent(Box<ModerationDefsAgeAssurancePurgeEvent>),
    ModerationDefsRevokeAccountCredentialsEvent(Box<ModerationDefsRevokeAccountCredentialsEvent>),
    ModerationDefsScheduleTakedownEvent(Box<ModerationDefsScheduleTakedownEvent>),
    ModerationDefsCancelScheduledTakedownEvent(Box<ModerationDefsCancelScheduledTakedownEvent>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ModerationDefsModEventViewEventUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventTakedown(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(
                            "tools.ozone.moderation.defs#modEventTakedown".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventReverseTakedown(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(
                            "tools.ozone.moderation.defs#modEventReverseTakedown".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventComment(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(
                            "tools.ozone.moderation.defs#modEventComment".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventReport(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(
                            "tools.ozone.moderation.defs#modEventReport".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventLabel(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(
                            "tools.ozone.moderation.defs#modEventLabel".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventAcknowledge(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(
                            "tools.ozone.moderation.defs#modEventAcknowledge".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventEscalate(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(
                            "tools.ozone.moderation.defs#modEventEscalate".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventMute(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(
                            "tools.ozone.moderation.defs#modEventMute".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventUnmute(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(
                            "tools.ozone.moderation.defs#modEventUnmute".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventMuteReporter(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(
                            "tools.ozone.moderation.defs#modEventMuteReporter".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventUnmuteReporter(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(
                            "tools.ozone.moderation.defs#modEventUnmuteReporter".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventEmail(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(
                            "tools.ozone.moderation.defs#modEventEmail".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventResolveAppeal(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(
                            "tools.ozone.moderation.defs#modEventResolveAppeal".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventDivert(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(
                            "tools.ozone.moderation.defs#modEventDivert".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventTag(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(
                            "tools.ozone.moderation.defs#modEventTag".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsAccountEvent(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(
                            "tools.ozone.moderation.defs#accountEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsIdentityEvent(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(
                            "tools.ozone.moderation.defs#identityEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsRecordEvent(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(
                            "tools.ozone.moderation.defs#recordEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventPriorityScore(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(
                            "tools.ozone.moderation.defs#modEventPriorityScore".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssuranceEvent(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(
                            "tools.ozone.moderation.defs#ageAssuranceEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssuranceOverrideEvent(
                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(
                            "tools.ozone.moderation.defs#ageAssuranceOverrideEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssurancePurgeEvent(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(
                            "tools.ozone.moderation.defs#ageAssurancePurgeEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsRevokeAccountCredentialsEvent(
                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(
                            "tools.ozone.moderation.defs#revokeAccountCredentialsEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsScheduleTakedownEvent(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(
                            "tools.ozone.moderation.defs#scheduleTakedownEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsCancelScheduledTakedownEvent(
                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(
                            "tools.ozone.moderation.defs#cancelScheduledTakedownEvent".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewEventUnion::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 ModerationDefsModEventViewEventUnion {
    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 {
            "tools.ozone.moderation.defs#modEventTakedown" => {
                let inner: ModerationDefsModEventTakedown =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventTakedown(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventReverseTakedown" => {
                let inner: ModerationDefsModEventReverseTakedown =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventReverseTakedown(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventComment" => {
                let inner: ModerationDefsModEventComment =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventComment(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventReport" => {
                let inner: ModerationDefsModEventReport =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventReport(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventLabel" => {
                let inner: ModerationDefsModEventLabel =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventLabel(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventAcknowledge" => {
                let inner: ModerationDefsModEventAcknowledge =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventAcknowledge(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventEscalate" => {
                let inner: ModerationDefsModEventEscalate =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventEscalate(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventMute" => {
                let inner: ModerationDefsModEventMute =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventMute(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventUnmute" => {
                let inner: ModerationDefsModEventUnmute =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventUnmute(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventMuteReporter" => {
                let inner: ModerationDefsModEventMuteReporter =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventMuteReporter(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventUnmuteReporter" => {
                let inner: ModerationDefsModEventUnmuteReporter =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventUnmuteReporter(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventEmail" => {
                let inner: ModerationDefsModEventEmail =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventEmail(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventResolveAppeal" => {
                let inner: ModerationDefsModEventResolveAppeal =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventResolveAppeal(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventDivert" => {
                let inner: ModerationDefsModEventDivert =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventDivert(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventTag" => {
                let inner: ModerationDefsModEventTag =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventTag(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#accountEvent" => {
                let inner: ModerationDefsAccountEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsAccountEvent(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#identityEvent" => {
                let inner: ModerationDefsIdentityEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsIdentityEvent(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#recordEvent" => {
                let inner: ModerationDefsRecordEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsRecordEvent(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventPriorityScore" => {
                let inner: ModerationDefsModEventPriorityScore =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventPriorityScore(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssuranceEvent" => {
                let inner: ModerationDefsAgeAssuranceEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssuranceEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssuranceOverrideEvent" => {
                let inner: ModerationDefsAgeAssuranceOverrideEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssuranceOverrideEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssurancePurgeEvent" => {
                let inner: ModerationDefsAgeAssurancePurgeEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssurancePurgeEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#revokeAccountCredentialsEvent" => {
                let inner: ModerationDefsRevokeAccountCredentialsEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewEventUnion::ModerationDefsRevokeAccountCredentialsEvent(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#scheduleTakedownEvent" => {
                let inner: ModerationDefsScheduleTakedownEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsScheduleTakedownEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#cancelScheduledTakedownEvent" => {
                let inner: ModerationDefsCancelScheduledTakedownEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewEventUnion::ModerationDefsCancelScheduledTakedownEvent(Box::new(inner)))
            }
            _ => Ok(ModerationDefsModEventViewEventUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ModerationDefsModEventViewEventUnion {
    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 {
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventTakedown(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventReverseTakedown(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventComment(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventReport(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventLabel(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventAcknowledge(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventEscalate(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventMute(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventUnmute(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventMuteReporter(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventUnmuteReporter(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventEmail(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventResolveAppeal(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventDivert(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventTag(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsAccountEvent(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsIdentityEvent(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsRecordEvent(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsModEventPriorityScore(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssuranceEvent(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssuranceOverrideEvent(
                inner,
            ) => inner.encode_cbor(buf),
            ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssurancePurgeEvent(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsRevokeAccountCredentialsEvent(
                inner,
            ) => inner.encode_cbor(buf),
            ModerationDefsModEventViewEventUnion::ModerationDefsScheduleTakedownEvent(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewEventUnion::ModerationDefsCancelScheduledTakedownEvent(
                inner,
            ) => inner.encode_cbor(buf),
            ModerationDefsModEventViewEventUnion::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 {
            "tools.ozone.moderation.defs#modEventTakedown" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventTakedown::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventTakedown(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventReverseTakedown" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventReverseTakedown::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventReverseTakedown(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventComment" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventComment::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventComment(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventReport" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventReport::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventReport(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventLabel" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventLabel::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventLabel(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventAcknowledge" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventAcknowledge::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventAcknowledge(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventEscalate" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventEscalate::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventEscalate(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventMute" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventMute::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventMute(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventUnmute" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventUnmute::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventUnmute(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventMuteReporter" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventMuteReporter::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventMuteReporter(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventUnmuteReporter" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventUnmuteReporter::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventUnmuteReporter(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventEmail" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventEmail::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventEmail(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventResolveAppeal" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventResolveAppeal::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventResolveAppeal(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventDivert" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventDivert::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventDivert(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventTag" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventTag::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventTag(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#accountEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAccountEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsAccountEvent(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#identityEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsIdentityEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsIdentityEvent(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#recordEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRecordEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsRecordEvent(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#modEventPriorityScore" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventPriorityScore::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsModEventPriorityScore(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssuranceEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAgeAssuranceEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssuranceEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssuranceOverrideEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAgeAssuranceOverrideEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssuranceOverrideEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssurancePurgeEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAgeAssurancePurgeEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsAgeAssurancePurgeEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#revokeAccountCredentialsEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRevokeAccountCredentialsEvent::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewEventUnion::ModerationDefsRevokeAccountCredentialsEvent(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#scheduleTakedownEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsScheduleTakedownEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewEventUnion::ModerationDefsScheduleTakedownEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#cancelScheduledTakedownEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsCancelScheduledTakedownEvent::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewEventUnion::ModerationDefsCancelScheduledTakedownEvent(Box::new(inner)))
            }
            _ => Ok(ModerationDefsModEventViewEventUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

/// ModerationDefsModEventViewSubjectUnion is a union type.
#[derive(Debug, Clone)]
pub enum ModerationDefsModEventViewSubjectUnion {
    AdminDefsRepoRef(Box<crate::api::com::atproto::AdminDefsRepoRef>),
    RepoStrongRef(Box<crate::api::com::atproto::RepoStrongRef>),
    ConvoDefsMessageRef(Box<crate::api::chat::bsky::ConvoDefsMessageRef>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ModerationDefsModEventViewSubjectUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ModerationDefsModEventViewSubjectUnion::AdminDefsRepoRef(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("com.atproto.admin.defs#repoRef".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewSubjectUnion::RepoStrongRef(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("com.atproto.repo.strongRef".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewSubjectUnion::ConvoDefsMessageRef(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageRef".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewSubjectUnion::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 ModerationDefsModEventViewSubjectUnion {
    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 {
            "com.atproto.admin.defs#repoRef" => {
                let inner: crate::api::com::atproto::AdminDefsRepoRef =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewSubjectUnion::AdminDefsRepoRef(
                    Box::new(inner),
                ))
            }
            "com.atproto.repo.strongRef" => {
                let inner: crate::api::com::atproto::RepoStrongRef =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewSubjectUnion::RepoStrongRef(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#messageRef" => {
                let inner: crate::api::chat::bsky::ConvoDefsMessageRef =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewSubjectUnion::ConvoDefsMessageRef(
                    Box::new(inner),
                ))
            }
            _ => Ok(ModerationDefsModEventViewSubjectUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ModerationDefsModEventViewSubjectUnion {
    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 {
            ModerationDefsModEventViewSubjectUnion::AdminDefsRepoRef(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewSubjectUnion::RepoStrongRef(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewSubjectUnion::ConvoDefsMessageRef(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewSubjectUnion::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 {
            "com.atproto.admin.defs#repoRef" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::com::atproto::AdminDefsRepoRef::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewSubjectUnion::AdminDefsRepoRef(
                    Box::new(inner),
                ))
            }
            "com.atproto.repo.strongRef" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::com::atproto::RepoStrongRef::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewSubjectUnion::RepoStrongRef(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#messageRef" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::chat::bsky::ConvoDefsMessageRef::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewSubjectUnion::ConvoDefsMessageRef(
                    Box::new(inner),
                ))
            }
            _ => Ok(ModerationDefsModEventViewSubjectUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ModerationDefsModEventView {
    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.mod_tool.is_some() {
                count += 1;
            }
            if self.creator_handle.is_some() {
                count += 1;
            }
            if self.subject_handle.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("id")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("event")?;
            self.event.encode_cbor(buf)?;
            if self.mod_tool.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("modTool")?;
                if let Some(ref val) = self.mod_tool {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("subject")?;
            self.subject.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdBy")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_by.as_str())?;
            if self.creator_handle.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("creatorHandle")?;
                if let Some(ref val) = self.creator_handle {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.subject_handle.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("subjectHandle")?;
                if let Some(ref val) = self.subject_handle {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("subjectBlobCids")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.subject_blob_cids.len() as u64)?;
            for item in &self.subject_blob_cids {
                crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
            }
        } 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_i64(self.id)?;
                pairs.push(("id", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.event.encode_cbor(&mut vbuf)?;
                pairs.push(("event", vbuf));
            }
            if self.mod_tool.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.mod_tool {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("modTool", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.subject.encode_cbor(&mut vbuf)?;
                pairs.push(("subject", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_by.as_str())?;
                pairs.push(("createdBy", vbuf));
            }
            if self.creator_handle.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.creator_handle {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("creatorHandle", vbuf));
            }
            if self.subject_handle.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.subject_handle {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("subjectHandle", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.subject_blob_cids.len() as u64)?;
                for item in &self.subject_blob_cids {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("subjectBlobCids", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

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

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

        let mut field_id: Option<i64> = None;
        let mut field_event: Option<ModerationDefsModEventViewEventUnion> = None;
        let mut field_mod_tool: Option<ModerationDefsModTool> = None;
        let mut field_subject: Option<ModerationDefsModEventViewSubjectUnion> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_created_by: Option<crate::syntax::Did> = None;
        let mut field_creator_handle: Option<String> = None;
        let mut field_subject_handle: Option<String> = None;
        let mut field_subject_blob_cids: Vec<String> = Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "id" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_id = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_id = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "event" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_event =
                        Some(ModerationDefsModEventViewEventUnion::decode_cbor(&mut dec)?);
                }
                "modTool" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_mod_tool = Some(ModerationDefsModTool::decode_cbor(&mut dec)?);
                }
                "subject" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_subject = Some(ModerationDefsModEventViewSubjectUnion::decode_cbor(
                        &mut dec,
                    )?);
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createdBy" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_by = 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()));
                    }
                }
                "creatorHandle" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_creator_handle = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "subjectHandle" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_subject_handle = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "subjectBlobCids" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_subject_blob_cids.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } 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(ModerationDefsModEventView {
            id: field_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'id'".into())
            })?,
            event: field_event.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'event'".into())
            })?,
            mod_tool: field_mod_tool,
            subject: field_subject.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'subject'".into())
            })?,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            created_by: field_created_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdBy'".into())
            })?,
            creator_handle: field_creator_handle,
            subject_handle: field_subject_handle,
            subject_blob_cids: field_subject_blob_cids,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModEventViewDetail object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModEventViewDetail {
    pub created_at: crate::syntax::Datetime,
    pub created_by: crate::syntax::Did,
    pub event: ModerationDefsModEventViewDetailEventUnion,
    pub id: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mod_tool: Option<ModerationDefsModTool>,
    pub subject: ModerationDefsModEventViewDetailSubjectUnion,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub subject_blobs: Vec<ModerationDefsBlobView>,
    /// 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>)>,
}

/// ModerationDefsModEventViewDetailEventUnion is a union type.
#[derive(Debug, Clone)]
pub enum ModerationDefsModEventViewDetailEventUnion {
    ModerationDefsModEventTakedown(Box<ModerationDefsModEventTakedown>),
    ModerationDefsModEventReverseTakedown(Box<ModerationDefsModEventReverseTakedown>),
    ModerationDefsModEventComment(Box<ModerationDefsModEventComment>),
    ModerationDefsModEventReport(Box<ModerationDefsModEventReport>),
    ModerationDefsModEventLabel(Box<ModerationDefsModEventLabel>),
    ModerationDefsModEventAcknowledge(Box<ModerationDefsModEventAcknowledge>),
    ModerationDefsModEventEscalate(Box<ModerationDefsModEventEscalate>),
    ModerationDefsModEventMute(Box<ModerationDefsModEventMute>),
    ModerationDefsModEventUnmute(Box<ModerationDefsModEventUnmute>),
    ModerationDefsModEventMuteReporter(Box<ModerationDefsModEventMuteReporter>),
    ModerationDefsModEventUnmuteReporter(Box<ModerationDefsModEventUnmuteReporter>),
    ModerationDefsModEventEmail(Box<ModerationDefsModEventEmail>),
    ModerationDefsModEventResolveAppeal(Box<ModerationDefsModEventResolveAppeal>),
    ModerationDefsModEventDivert(Box<ModerationDefsModEventDivert>),
    ModerationDefsModEventTag(Box<ModerationDefsModEventTag>),
    ModerationDefsAccountEvent(Box<ModerationDefsAccountEvent>),
    ModerationDefsIdentityEvent(Box<ModerationDefsIdentityEvent>),
    ModerationDefsRecordEvent(Box<ModerationDefsRecordEvent>),
    ModerationDefsModEventPriorityScore(Box<ModerationDefsModEventPriorityScore>),
    ModerationDefsAgeAssuranceEvent(Box<ModerationDefsAgeAssuranceEvent>),
    ModerationDefsAgeAssuranceOverrideEvent(Box<ModerationDefsAgeAssuranceOverrideEvent>),
    ModerationDefsAgeAssurancePurgeEvent(Box<ModerationDefsAgeAssurancePurgeEvent>),
    ModerationDefsRevokeAccountCredentialsEvent(Box<ModerationDefsRevokeAccountCredentialsEvent>),
    ModerationDefsScheduleTakedownEvent(Box<ModerationDefsScheduleTakedownEvent>),
    ModerationDefsCancelScheduledTakedownEvent(Box<ModerationDefsCancelScheduledTakedownEvent>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ModerationDefsModEventViewDetailEventUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventTakedown(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("tools.ozone.moderation.defs#modEventTakedown".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventReverseTakedown(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("tools.ozone.moderation.defs#modEventReverseTakedown".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventComment(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("tools.ozone.moderation.defs#modEventComment".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventReport(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("tools.ozone.moderation.defs#modEventReport".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventLabel(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("tools.ozone.moderation.defs#modEventLabel".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventAcknowledge(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("tools.ozone.moderation.defs#modEventAcknowledge".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventEscalate(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("tools.ozone.moderation.defs#modEventEscalate".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventMute(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("tools.ozone.moderation.defs#modEventMute".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventUnmute(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("tools.ozone.moderation.defs#modEventUnmute".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventMuteReporter(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("tools.ozone.moderation.defs#modEventMuteReporter".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventUnmuteReporter(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("tools.ozone.moderation.defs#modEventUnmuteReporter".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventEmail(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("tools.ozone.moderation.defs#modEventEmail".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventResolveAppeal(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("tools.ozone.moderation.defs#modEventResolveAppeal".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventDivert(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("tools.ozone.moderation.defs#modEventDivert".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventTag(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("tools.ozone.moderation.defs#modEventTag".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsAccountEvent(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("tools.ozone.moderation.defs#accountEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsIdentityEvent(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("tools.ozone.moderation.defs#identityEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsRecordEvent(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("tools.ozone.moderation.defs#recordEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventPriorityScore(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("tools.ozone.moderation.defs#modEventPriorityScore".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssuranceEvent(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("tools.ozone.moderation.defs#ageAssuranceEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssuranceOverrideEvent(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("tools.ozone.moderation.defs#ageAssuranceOverrideEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssurancePurgeEvent(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("tools.ozone.moderation.defs#ageAssurancePurgeEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsRevokeAccountCredentialsEvent(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("tools.ozone.moderation.defs#revokeAccountCredentialsEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsScheduleTakedownEvent(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("tools.ozone.moderation.defs#scheduleTakedownEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsCancelScheduledTakedownEvent(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("tools.ozone.moderation.defs#cancelScheduledTakedownEvent".to_string()));
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailEventUnion::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 ModerationDefsModEventViewDetailEventUnion {
    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 {
            "tools.ozone.moderation.defs#modEventTakedown" => {
                let inner: ModerationDefsModEventTakedown =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventTakedown(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventReverseTakedown" => {
                let inner: ModerationDefsModEventReverseTakedown =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventReverseTakedown(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#modEventComment" => {
                let inner: ModerationDefsModEventComment =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventComment(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventReport" => {
                let inner: ModerationDefsModEventReport =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventReport(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventLabel" => {
                let inner: ModerationDefsModEventLabel =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventLabel(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventAcknowledge" => {
                let inner: ModerationDefsModEventAcknowledge =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventAcknowledge(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventEscalate" => {
                let inner: ModerationDefsModEventEscalate =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventEscalate(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventMute" => {
                let inner: ModerationDefsModEventMute =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventMute(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventUnmute" => {
                let inner: ModerationDefsModEventUnmute =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventUnmute(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventMuteReporter" => {
                let inner: ModerationDefsModEventMuteReporter =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventMuteReporter(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventUnmuteReporter" => {
                let inner: ModerationDefsModEventUnmuteReporter =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventUnmuteReporter(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#modEventEmail" => {
                let inner: ModerationDefsModEventEmail =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventEmail(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventResolveAppeal" => {
                let inner: ModerationDefsModEventResolveAppeal =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventResolveAppeal(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventDivert" => {
                let inner: ModerationDefsModEventDivert =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventDivert(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventTag" => {
                let inner: ModerationDefsModEventTag =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventTag(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#accountEvent" => {
                let inner: ModerationDefsAccountEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsAccountEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#identityEvent" => {
                let inner: ModerationDefsIdentityEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsIdentityEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#recordEvent" => {
                let inner: ModerationDefsRecordEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsRecordEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventPriorityScore" => {
                let inner: ModerationDefsModEventPriorityScore =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventPriorityScore(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssuranceEvent" => {
                let inner: ModerationDefsAgeAssuranceEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssuranceEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssuranceOverrideEvent" => {
                let inner: ModerationDefsAgeAssuranceOverrideEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssuranceOverrideEvent(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#ageAssurancePurgeEvent" => {
                let inner: ModerationDefsAgeAssurancePurgeEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssurancePurgeEvent(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#revokeAccountCredentialsEvent" => {
                let inner: ModerationDefsRevokeAccountCredentialsEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsRevokeAccountCredentialsEvent(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#scheduleTakedownEvent" => {
                let inner: ModerationDefsScheduleTakedownEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsScheduleTakedownEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#cancelScheduledTakedownEvent" => {
                let inner: ModerationDefsCancelScheduledTakedownEvent =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsCancelScheduledTakedownEvent(Box::new(inner)))
            }
            _ => Ok(ModerationDefsModEventViewDetailEventUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ModerationDefsModEventViewDetailEventUnion {
    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 {
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventTakedown(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventReverseTakedown(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventComment(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventReport(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventLabel(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventAcknowledge(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventEscalate(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventMute(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventUnmute(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventMuteReporter(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventUnmuteReporter(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventEmail(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventResolveAppeal(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventDivert(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventTag(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsAccountEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsIdentityEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsRecordEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventPriorityScore(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssuranceEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssuranceOverrideEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssurancePurgeEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsRevokeAccountCredentialsEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsScheduleTakedownEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::ModerationDefsCancelScheduledTakedownEvent(inner) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailEventUnion::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 {
            "tools.ozone.moderation.defs#modEventTakedown" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventTakedown::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventTakedown(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventReverseTakedown" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventReverseTakedown::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventReverseTakedown(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#modEventComment" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventComment::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventComment(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventReport" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventReport::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventReport(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventLabel" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventLabel::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventLabel(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventAcknowledge" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventAcknowledge::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventAcknowledge(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventEscalate" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventEscalate::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventEscalate(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventMute" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventMute::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventMute(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventUnmute" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventUnmute::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventUnmute(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventMuteReporter" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventMuteReporter::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventMuteReporter(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventUnmuteReporter" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventUnmuteReporter::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventUnmuteReporter(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#modEventEmail" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventEmail::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventEmail(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventResolveAppeal" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventResolveAppeal::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventResolveAppeal(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventDivert" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventDivert::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventDivert(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventTag" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventTag::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventTag(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#accountEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAccountEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsAccountEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#identityEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsIdentityEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsIdentityEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#recordEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRecordEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsRecordEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#modEventPriorityScore" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsModEventPriorityScore::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsModEventPriorityScore(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssuranceEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAgeAssuranceEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssuranceEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#ageAssuranceOverrideEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAgeAssuranceOverrideEvent::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssuranceOverrideEvent(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#ageAssurancePurgeEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAgeAssurancePurgeEvent::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsAgeAssurancePurgeEvent(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#revokeAccountCredentialsEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRevokeAccountCredentialsEvent::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsRevokeAccountCredentialsEvent(Box::new(inner)))
            }
            "tools.ozone.moderation.defs#scheduleTakedownEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsScheduleTakedownEvent::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailEventUnion::ModerationDefsScheduleTakedownEvent(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#cancelScheduledTakedownEvent" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsCancelScheduledTakedownEvent::decode_cbor(&mut dec)?;
                Ok(ModerationDefsModEventViewDetailEventUnion::ModerationDefsCancelScheduledTakedownEvent(Box::new(inner)))
            }
            _ => Ok(ModerationDefsModEventViewDetailEventUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

/// ModerationDefsModEventViewDetailSubjectUnion is a union type.
#[derive(Debug, Clone)]
pub enum ModerationDefsModEventViewDetailSubjectUnion {
    ModerationDefsRepoView(Box<ModerationDefsRepoView>),
    ModerationDefsRepoViewNotFound(Box<ModerationDefsRepoViewNotFound>),
    ModerationDefsRecordView(Box<ModerationDefsRecordView>),
    ModerationDefsRecordViewNotFound(Box<ModerationDefsRecordViewNotFound>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ModerationDefsModEventViewDetailSubjectUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRepoView(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(
                            "tools.ozone.moderation.defs#repoView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRepoViewNotFound(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(
                            "tools.ozone.moderation.defs#repoViewNotFound".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRecordView(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(
                            "tools.ozone.moderation.defs#recordView".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRecordViewNotFound(
                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(
                            "tools.ozone.moderation.defs#recordViewNotFound".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsModEventViewDetailSubjectUnion::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 ModerationDefsModEventViewDetailSubjectUnion {
    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 {
            "tools.ozone.moderation.defs#repoView" => {
                let inner: ModerationDefsRepoView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRepoView(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#repoViewNotFound" => {
                let inner: ModerationDefsRepoViewNotFound =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRepoViewNotFound(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#recordView" => {
                let inner: ModerationDefsRecordView =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRecordView(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#recordViewNotFound" => {
                let inner: ModerationDefsRecordViewNotFound =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRecordViewNotFound(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(ModerationDefsModEventViewDetailSubjectUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ModerationDefsModEventViewDetailSubjectUnion {
    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 {
            ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRepoView(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRepoViewNotFound(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRecordView(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRecordViewNotFound(
                inner,
            ) => inner.encode_cbor(buf),
            ModerationDefsModEventViewDetailSubjectUnion::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 {
            "tools.ozone.moderation.defs#repoView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRepoView::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRepoView(Box::new(
                        inner,
                    )),
                )
            }
            "tools.ozone.moderation.defs#repoViewNotFound" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRepoViewNotFound::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRepoViewNotFound(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#recordView" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRecordView::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRecordView(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#recordViewNotFound" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRecordViewNotFound::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsModEventViewDetailSubjectUnion::ModerationDefsRecordViewNotFound(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(ModerationDefsModEventViewDetailSubjectUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ModerationDefsModEventViewDetail {
    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.mod_tool.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("id")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.id)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("event")?;
            self.event.encode_cbor(buf)?;
            if self.mod_tool.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("modTool")?;
                if let Some(ref val) = self.mod_tool {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("subject")?;
            self.subject.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdBy")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_by.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("subjectBlobs")?;
            crate::cbor::Encoder::new(&mut *buf)
                .encode_array_header(self.subject_blobs.len() as u64)?;
            for item in &self.subject_blobs {
                item.encode_cbor(buf)?;
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.id)?;
                pairs.push(("id", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.event.encode_cbor(&mut vbuf)?;
                pairs.push(("event", vbuf));
            }
            if self.mod_tool.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.mod_tool {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("modTool", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.subject.encode_cbor(&mut vbuf)?;
                pairs.push(("subject", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_by.as_str())?;
                pairs.push(("createdBy", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.subject_blobs.len() as u64)?;
                for item in &self.subject_blobs {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("subjectBlobs", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

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

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

        let mut field_id: Option<i64> = None;
        let mut field_event: Option<ModerationDefsModEventViewDetailEventUnion> = None;
        let mut field_mod_tool: Option<ModerationDefsModTool> = None;
        let mut field_subject: Option<ModerationDefsModEventViewDetailSubjectUnion> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_created_by: Option<crate::syntax::Did> = None;
        let mut field_subject_blobs: Vec<ModerationDefsBlobView> = Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "id" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_id = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_id = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "event" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_event = Some(ModerationDefsModEventViewDetailEventUnion::decode_cbor(
                        &mut dec,
                    )?);
                }
                "modTool" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_mod_tool = Some(ModerationDefsModTool::decode_cbor(&mut dec)?);
                }
                "subject" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_subject = Some(
                        ModerationDefsModEventViewDetailSubjectUnion::decode_cbor(&mut dec)?,
                    );
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createdBy" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_by = 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()));
                    }
                }
                "subjectBlobs" => {
                    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_subject_blobs
                                .push(ModerationDefsBlobView::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(ModerationDefsModEventViewDetail {
            id: field_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'id'".into())
            })?,
            event: field_event.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'event'".into())
            })?,
            mod_tool: field_mod_tool,
            subject: field_subject.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'subject'".into())
            })?,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            created_by: field_created_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdBy'".into())
            })?,
            subject_blobs: field_subject_blobs,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModTool — Moderation tool information for tracing the source of the action
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModTool {
    /// Additional arbitrary metadata about the source
    pub meta: serde_json::Value,
    /// Name/identifier of the source (e.g., 'automod', 'ozone/workspace')
    pub name: 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 ModerationDefsModTool {
    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("name")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.name)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.name)?;
                pairs.push(("name", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

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

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

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

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

        Ok(ModerationDefsModTool {
            meta: Default::default(),
            name: field_name.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'name'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModeration object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModeration {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subject_status: Option<ModerationDefsSubjectStatusView>,
    /// 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 ModerationDefsModeration {
    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.subject_status.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.subject_status.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("subjectStatus")?;
                if let Some(ref val) = self.subject_status {
                    val.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.subject_status.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.subject_status {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("subjectStatus", 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_status: Option<ModerationDefsSubjectStatusView> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

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

        Ok(ModerationDefsModeration {
            subject_status: field_subject_status,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsModerationDetail object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsModerationDetail {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subject_status: Option<ModerationDefsSubjectStatusView>,
    /// 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 ModerationDefsModerationDetail {
    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.subject_status.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.subject_status.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("subjectStatus")?;
                if let Some(ref val) = self.subject_status {
                    val.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.subject_status.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.subject_status {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("subjectStatus", 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_status: Option<ModerationDefsSubjectStatusView> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

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

        Ok(ModerationDefsModerationDetail {
            subject_status: field_subject_status,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsRecordEvent — Logs lifecycle event on a record subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRecordEvent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cid: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    pub op: String,
    pub timestamp: crate::syntax::Datetime,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsRecordEvent {
    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.comment.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("op")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.op)?;
            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.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("timestamp")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.timestamp.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.op)?;
                pairs.push(("op", 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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.timestamp.as_str())?;
                pairs.push(("timestamp", 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_op: Option<String> = None;
        let mut field_cid: Option<String> = None;
        let mut field_comment: Option<String> = None;
        let mut field_timestamp: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "op" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_op = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "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()));
                    }
                }
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "timestamp" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_timestamp = 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(ModerationDefsRecordEvent {
            op: field_op.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'op'".into())
            })?,
            cid: field_cid,
            comment: field_comment,
            timestamp: field_timestamp.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'timestamp'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsRecordHosting object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRecordHosting {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted_at: Option<crate::syntax::Datetime>,
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<crate::syntax::Datetime>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsRecordHosting {
    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.created_at.is_some() {
                count += 1;
            }
            if self.deleted_at.is_some() {
                count += 1;
            }
            if self.updated_at.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("status")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.status)?;
            if self.created_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
                if let Some(ref val) = self.created_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.deleted_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("deletedAt")?;
                if let Some(ref val) = self.deleted_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.updated_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("updatedAt")?;
                if let Some(ref val) = self.updated_at {
                    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();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.status)?;
                pairs.push(("status", vbuf));
            }
            if self.created_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.created_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("createdAt", vbuf));
            }
            if self.deleted_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.deleted_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("deletedAt", vbuf));
            }
            if self.updated_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.updated_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("updatedAt", 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_status: Option<String> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_deleted_at: Option<crate::syntax::Datetime> = None;
        let mut field_updated_at: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "status" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_status = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "deletedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_deleted_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()));
                    }
                }
                "updatedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_updated_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(ModerationDefsRecordHosting {
            status: field_status.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'status'".into())
            })?,
            created_at: field_created_at,
            deleted_at: field_deleted_at,
            updated_at: field_updated_at,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsRecordView object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRecordView {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub blob_cids: Vec<String>,
    pub cid: String,
    pub indexed_at: crate::syntax::Datetime,
    pub moderation: ModerationDefsModeration,
    pub repo: ModerationDefsRepoView,
    pub uri: crate::syntax::AtUri,
    pub value: serde_json::Value,
    /// 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 ModerationDefsRecordView {
    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 = 6u64;
            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())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("repo")?;
            self.repo.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("blobCids")?;
            crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.blob_cids.len() as u64)?;
            for item in &self.blob_cids {
                crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("indexedAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.indexed_at.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("moderation")?;
            self.moderation.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.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));
            }
            {
                let mut vbuf = Vec::new();
                self.repo.encode_cbor(&mut vbuf)?;
                pairs.push(("repo", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.blob_cids.len() as u64)?;
                for item in &self.blob_cids {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("blobCids", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.indexed_at.as_str())?;
                pairs.push(("indexedAt", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.moderation.encode_cbor(&mut vbuf)?;
                pairs.push(("moderation", 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_repo: Option<ModerationDefsRepoView> = None;
        let mut field_blob_cids: Vec<String> = Vec::new();
        let mut field_indexed_at: Option<crate::syntax::Datetime> = None;
        let mut field_moderation: Option<ModerationDefsModeration> = 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()));
                    }
                }
                "repo" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_repo = Some(ModerationDefsRepoView::decode_cbor(&mut dec)?);
                }
                "blobCids" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_blob_cids.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".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()));
                    }
                }
                "moderation" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_moderation = Some(ModerationDefsModeration::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ModerationDefsRecordView {
            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())
            })?,
            repo: field_repo.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'repo'".into())
            })?,
            value: Default::default(),
            blob_cids: field_blob_cids,
            indexed_at: field_indexed_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'indexedAt'".into())
            })?,
            moderation: field_moderation.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'moderation'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsRecordViewDetail object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRecordViewDetail {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub blobs: Vec<ModerationDefsBlobView>,
    pub cid: String,
    pub indexed_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub labels: Vec<crate::api::com::atproto::LabelDefsLabel>,
    pub moderation: ModerationDefsModerationDetail,
    pub repo: ModerationDefsRepoView,
    pub uri: crate::syntax::AtUri,
    pub value: serde_json::Value,
    /// 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 ModerationDefsRecordViewDetail {
    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.labels.is_empty() {
                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())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("repo")?;
            self.repo.encode_cbor(buf)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("blobs")?;
            crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.blobs.len() as u64)?;
            for item in &self.blobs {
                item.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)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("indexedAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.indexed_at.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("moderation")?;
            self.moderation.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.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));
            }
            {
                let mut vbuf = Vec::new();
                self.repo.encode_cbor(&mut vbuf)?;
                pairs.push(("repo", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_array_header(self.blobs.len() as u64)?;
                for item in &self.blobs {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("blobs", 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));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.indexed_at.as_str())?;
                pairs.push(("indexedAt", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.moderation.encode_cbor(&mut vbuf)?;
                pairs.push(("moderation", 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_repo: Option<ModerationDefsRepoView> = None;
        let mut field_blobs: Vec<ModerationDefsBlobView> = Vec::new();
        let mut field_labels: Vec<crate::api::com::atproto::LabelDefsLabel> = Vec::new();
        let mut field_indexed_at: Option<crate::syntax::Datetime> = None;
        let mut field_moderation: Option<ModerationDefsModerationDetail> = 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()));
                    }
                }
                "repo" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_repo = Some(ModerationDefsRepoView::decode_cbor(&mut dec)?);
                }
                "blobs" => {
                    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_blobs.push(ModerationDefsBlobView::decode_cbor(&mut dec)?);
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".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()));
                    }
                }
                "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()));
                    }
                }
                "moderation" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_moderation = Some(ModerationDefsModerationDetail::decode_cbor(&mut dec)?);
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(ModerationDefsRecordViewDetail {
            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())
            })?,
            repo: field_repo.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'repo'".into())
            })?,
            blobs: field_blobs,
            value: Default::default(),
            labels: field_labels,
            indexed_at: field_indexed_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'indexedAt'".into())
            })?,
            moderation: field_moderation.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'moderation'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsRecordViewNotFound object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRecordViewNotFound {
    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 ModerationDefsRecordViewNotFound {
    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("uri")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.uri.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.uri.as_str())?;
                pairs.push(("uri", 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 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()));
                    }
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

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

/// ModerationDefsRecordsStats — Statistics about a set of record subject items
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRecordsStats {
    /// Number of items that were appealed at least once
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub appealed_count: Option<i64>,
    /// Number of items that were escalated at least once
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub escalated_count: Option<i64>,
    /// Number of item currently in "reviewOpen" or "reviewEscalated" state
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pending_count: Option<i64>,
    /// Number of item currently in "reviewNone" or "reviewClosed" state
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub processed_count: Option<i64>,
    /// Number of items that were reported at least once
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reported_count: Option<i64>,
    /// Total number of item in the set
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subject_count: Option<i64>,
    /// Number of item currently taken down
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub takendown_count: Option<i64>,
    /// Cumulative sum of the number of reports on the items in the set
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_reports: Option<i64>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsRecordsStats {
    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.pending_count.is_some() {
                count += 1;
            }
            if self.subject_count.is_some() {
                count += 1;
            }
            if self.total_reports.is_some() {
                count += 1;
            }
            if self.appealed_count.is_some() {
                count += 1;
            }
            if self.reported_count.is_some() {
                count += 1;
            }
            if self.escalated_count.is_some() {
                count += 1;
            }
            if self.processed_count.is_some() {
                count += 1;
            }
            if self.takendown_count.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.pending_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("pendingCount")?;
                if let Some(ref val) = self.pending_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.subject_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("subjectCount")?;
                if let Some(ref val) = self.subject_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.total_reports.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("totalReports")?;
                if let Some(ref val) = self.total_reports {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.appealed_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("appealedCount")?;
                if let Some(ref val) = self.appealed_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.reported_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("reportedCount")?;
                if let Some(ref val) = self.reported_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.escalated_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("escalatedCount")?;
                if let Some(ref val) = self.escalated_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.processed_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("processedCount")?;
                if let Some(ref val) = self.processed_count {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.takendown_count.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("takendownCount")?;
                if let Some(ref val) = self.takendown_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();
            if self.pending_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.pending_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("pendingCount", vbuf));
            }
            if self.subject_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.subject_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("subjectCount", vbuf));
            }
            if self.total_reports.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.total_reports {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("totalReports", vbuf));
            }
            if self.appealed_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.appealed_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("appealedCount", vbuf));
            }
            if self.reported_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.reported_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("reportedCount", vbuf));
            }
            if self.escalated_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.escalated_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("escalatedCount", vbuf));
            }
            if self.processed_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.processed_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("processedCount", vbuf));
            }
            if self.takendown_count.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.takendown_count {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("takendownCount", 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_pending_count: Option<i64> = None;
        let mut field_subject_count: Option<i64> = None;
        let mut field_total_reports: Option<i64> = None;
        let mut field_appealed_count: Option<i64> = None;
        let mut field_reported_count: Option<i64> = None;
        let mut field_escalated_count: Option<i64> = None;
        let mut field_processed_count: Option<i64> = None;
        let mut field_takendown_count: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "pendingCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_pending_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_pending_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "subjectCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_subject_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_subject_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "totalReports" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_total_reports = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_total_reports = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "appealedCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_appealed_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_appealed_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "reportedCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_reported_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_reported_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "escalatedCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_escalated_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_escalated_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "processedCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_processed_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_processed_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "takendownCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_takendown_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_takendown_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(ModerationDefsRecordsStats {
            pending_count: field_pending_count,
            subject_count: field_subject_count,
            total_reports: field_total_reports,
            appealed_count: field_appealed_count,
            reported_count: field_reported_count,
            escalated_count: field_escalated_count,
            processed_count: field_processed_count,
            takendown_count: field_takendown_count,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsRepoView object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRepoView {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deactivated_at: Option<crate::syntax::Datetime>,
    pub did: crate::syntax::Did,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    pub handle: crate::syntax::Handle,
    pub indexed_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invite_note: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invited_by: Option<crate::api::com::atproto::ServerDefsInviteCode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invites_disabled: Option<bool>,
    pub moderation: ModerationDefsModeration,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_records: Vec<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub threat_signatures: Vec<crate::api::com::atproto::AdminDefsThreatSignature>,
    /// 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 ModerationDefsRepoView {
    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.email.is_some() {
                count += 1;
            }
            if self.invited_by.is_some() {
                count += 1;
            }
            if self.invite_note.is_some() {
                count += 1;
            }
            if self.deactivated_at.is_some() {
                count += 1;
            }
            if self.invites_disabled.is_some() {
                count += 1;
            }
            if !self.threat_signatures.is_empty() {
                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.email.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("email")?;
                if let Some(ref val) = self.email {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("handle")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.handle.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("indexedAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.indexed_at.as_str())?;
            if self.invited_by.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("invitedBy")?;
                if let Some(ref val) = self.invited_by {
                    val.encode_cbor(buf)?;
                }
            }
            if self.invite_note.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("inviteNote")?;
                if let Some(ref val) = self.invite_note {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("moderation")?;
            self.moderation.encode_cbor(buf)?;
            if self.deactivated_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("deactivatedAt")?;
                if let Some(ref val) = self.deactivated_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.invites_disabled.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("invitesDisabled")?;
                if let Some(ref val) = self.invites_disabled {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            if !self.threat_signatures.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("threatSignatures")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.threat_signatures.len() as u64)?;
                for item in &self.threat_signatures {
                    item.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            if self.email.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.email {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("email", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.handle.as_str())?;
                pairs.push(("handle", 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.invited_by.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.invited_by {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("invitedBy", vbuf));
            }
            if self.invite_note.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.invite_note {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("inviteNote", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.moderation.encode_cbor(&mut vbuf)?;
                pairs.push(("moderation", vbuf));
            }
            if self.deactivated_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.deactivated_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("deactivatedAt", vbuf));
            }
            if self.invites_disabled.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.invites_disabled {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("invitesDisabled", vbuf));
            }
            if !self.threat_signatures.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.threat_signatures.len() as u64)?;
                for item in &self.threat_signatures {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("threatSignatures", 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_email: Option<String> = None;
        let mut field_handle: Option<crate::syntax::Handle> = None;
        let mut field_indexed_at: Option<crate::syntax::Datetime> = None;
        let mut field_invited_by: Option<crate::api::com::atproto::ServerDefsInviteCode> = None;
        let mut field_invite_note: Option<String> = None;
        let mut field_moderation: Option<ModerationDefsModeration> = None;
        let mut field_deactivated_at: Option<crate::syntax::Datetime> = None;
        let mut field_invites_disabled: Option<bool> = None;
        let mut field_threat_signatures: Vec<crate::api::com::atproto::AdminDefsThreatSignature> =
            Vec::new();
        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()));
                    }
                }
                "email" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_email = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "handle" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_handle = Some(
                            crate::syntax::Handle::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()));
                    }
                }
                "invitedBy" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_invited_by = Some(
                        crate::api::com::atproto::ServerDefsInviteCode::decode_cbor(&mut dec)?,
                    );
                }
                "inviteNote" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_invite_note = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "moderation" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_moderation = Some(ModerationDefsModeration::decode_cbor(&mut dec)?);
                }
                "deactivatedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_deactivated_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()));
                    }
                }
                "invitesDisabled" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_invites_disabled = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "threatSignatures" => {
                    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_threat_signatures.push(
                                crate::api::com::atproto::AdminDefsThreatSignature::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(ModerationDefsRepoView {
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            email: field_email,
            handle: field_handle.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'handle'".into())
            })?,
            indexed_at: field_indexed_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'indexedAt'".into())
            })?,
            invited_by: field_invited_by,
            invite_note: field_invite_note,
            moderation: field_moderation.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'moderation'".into())
            })?,
            deactivated_at: field_deactivated_at,
            related_records: Default::default(),
            invites_disabled: field_invites_disabled,
            threat_signatures: field_threat_signatures,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsRepoViewDetail object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRepoViewDetail {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deactivated_at: Option<crate::syntax::Datetime>,
    pub did: crate::syntax::Did,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email_confirmed_at: Option<crate::syntax::Datetime>,
    pub handle: crate::syntax::Handle,
    pub indexed_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invite_note: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invited_by: Option<crate::api::com::atproto::ServerDefsInviteCode>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub invites: Vec<crate::api::com::atproto::ServerDefsInviteCode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invites_disabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub labels: Vec<crate::api::com::atproto::LabelDefsLabel>,
    pub moderation: ModerationDefsModerationDetail,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub related_records: Vec<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub threat_signatures: Vec<crate::api::com::atproto::AdminDefsThreatSignature>,
    /// 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 ModerationDefsRepoViewDetail {
    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.email.is_some() {
                count += 1;
            }
            if !self.labels.is_empty() {
                count += 1;
            }
            if !self.invites.is_empty() {
                count += 1;
            }
            if self.invited_by.is_some() {
                count += 1;
            }
            if self.invite_note.is_some() {
                count += 1;
            }
            if self.deactivated_at.is_some() {
                count += 1;
            }
            if self.invites_disabled.is_some() {
                count += 1;
            }
            if self.email_confirmed_at.is_some() {
                count += 1;
            }
            if !self.threat_signatures.is_empty() {
                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.email.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("email")?;
                if let Some(ref val) = self.email {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("handle")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.handle.as_str())?;
            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.invites.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("invites")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.invites.len() as u64)?;
                for item in &self.invites {
                    item.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.invited_by.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("invitedBy")?;
                if let Some(ref val) = self.invited_by {
                    val.encode_cbor(buf)?;
                }
            }
            if self.invite_note.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("inviteNote")?;
                if let Some(ref val) = self.invite_note {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("moderation")?;
            self.moderation.encode_cbor(buf)?;
            if self.deactivated_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("deactivatedAt")?;
                if let Some(ref val) = self.deactivated_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.invites_disabled.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("invitesDisabled")?;
                if let Some(ref val) = self.invites_disabled {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            if self.email_confirmed_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("emailConfirmedAt")?;
                if let Some(ref val) = self.email_confirmed_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if !self.threat_signatures.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("threatSignatures")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.threat_signatures.len() as u64)?;
                for item in &self.threat_signatures {
                    item.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            if self.email.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.email {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("email", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.handle.as_str())?;
                pairs.push(("handle", 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.invites.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.invites.len() as u64)?;
                for item in &self.invites {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("invites", 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.invited_by.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.invited_by {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("invitedBy", vbuf));
            }
            if self.invite_note.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.invite_note {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("inviteNote", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.moderation.encode_cbor(&mut vbuf)?;
                pairs.push(("moderation", vbuf));
            }
            if self.deactivated_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.deactivated_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("deactivatedAt", vbuf));
            }
            if self.invites_disabled.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.invites_disabled {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("invitesDisabled", vbuf));
            }
            if self.email_confirmed_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.email_confirmed_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("emailConfirmedAt", vbuf));
            }
            if !self.threat_signatures.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.threat_signatures.len() as u64)?;
                for item in &self.threat_signatures {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("threatSignatures", 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_email: Option<String> = None;
        let mut field_handle: Option<crate::syntax::Handle> = None;
        let mut field_labels: Vec<crate::api::com::atproto::LabelDefsLabel> = Vec::new();
        let mut field_invites: Vec<crate::api::com::atproto::ServerDefsInviteCode> = Vec::new();
        let mut field_indexed_at: Option<crate::syntax::Datetime> = None;
        let mut field_invited_by: Option<crate::api::com::atproto::ServerDefsInviteCode> = None;
        let mut field_invite_note: Option<String> = None;
        let mut field_moderation: Option<ModerationDefsModerationDetail> = None;
        let mut field_deactivated_at: Option<crate::syntax::Datetime> = None;
        let mut field_invites_disabled: Option<bool> = None;
        let mut field_email_confirmed_at: Option<crate::syntax::Datetime> = None;
        let mut field_threat_signatures: Vec<crate::api::com::atproto::AdminDefsThreatSignature> =
            Vec::new();
        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()));
                    }
                }
                "email" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_email = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "handle" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_handle = Some(
                            crate::syntax::Handle::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.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()));
                    }
                }
                "invites" => {
                    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_invites.push(
                                crate::api::com::atproto::ServerDefsInviteCode::decode_cbor(
                                    &mut dec,
                                )?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".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()));
                    }
                }
                "invitedBy" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_invited_by = Some(
                        crate::api::com::atproto::ServerDefsInviteCode::decode_cbor(&mut dec)?,
                    );
                }
                "inviteNote" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_invite_note = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "moderation" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_moderation = Some(ModerationDefsModerationDetail::decode_cbor(&mut dec)?);
                }
                "deactivatedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_deactivated_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()));
                    }
                }
                "invitesDisabled" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_invites_disabled = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "emailConfirmedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_email_confirmed_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()));
                    }
                }
                "threatSignatures" => {
                    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_threat_signatures.push(
                                crate::api::com::atproto::AdminDefsThreatSignature::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(ModerationDefsRepoViewDetail {
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            email: field_email,
            handle: field_handle.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'handle'".into())
            })?,
            labels: field_labels,
            invites: field_invites,
            indexed_at: field_indexed_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'indexedAt'".into())
            })?,
            invited_by: field_invited_by,
            invite_note: field_invite_note,
            moderation: field_moderation.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'moderation'".into())
            })?,
            deactivated_at: field_deactivated_at,
            related_records: Default::default(),
            invites_disabled: field_invites_disabled,
            email_confirmed_at: field_email_confirmed_at,
            threat_signatures: field_threat_signatures,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

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

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

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

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

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

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

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

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

/// ModerationDefsReporterStats object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsReporterStats {
    /// The total number of reports made by the user on accounts.
    pub account_report_count: i64,
    pub did: crate::syntax::Did,
    /// The total number of accounts labeled as a result of the user's reports.
    pub labeled_account_count: i64,
    /// The total number of records labeled as a result of the user's reports.
    pub labeled_record_count: i64,
    /// The total number of reports made by the user on records.
    pub record_report_count: i64,
    /// The total number of accounts reported by the user.
    pub reported_account_count: i64,
    /// The total number of records reported by the user.
    pub reported_record_count: i64,
    /// The total number of accounts taken down as a result of the user's reports.
    pub takendown_account_count: i64,
    /// The total number of records taken down as a result of the user's reports.
    pub takendown_record_count: i64,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsReporterStats {
    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 = 9u64;
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("did")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.did.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("recordReportCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.record_report_count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("accountReportCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.account_report_count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("labeledRecordCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.labeled_record_count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("labeledAccountCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.labeled_account_count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("reportedRecordCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.reported_record_count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("reportedAccountCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.reported_account_count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("takendownRecordCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.takendown_record_count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("takendownAccountCount")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.takendown_account_count)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.did.as_str())?;
                pairs.push(("did", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.record_report_count)?;
                pairs.push(("recordReportCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.account_report_count)?;
                pairs.push(("accountReportCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.labeled_record_count)?;
                pairs.push(("labeledRecordCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.labeled_account_count)?;
                pairs.push(("labeledAccountCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.reported_record_count)?;
                pairs.push(("reportedRecordCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.reported_account_count)?;
                pairs.push(("reportedAccountCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.takendown_record_count)?;
                pairs.push(("takendownRecordCount", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.takendown_account_count)?;
                pairs.push(("takendownAccountCount", 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_record_report_count: Option<i64> = None;
        let mut field_account_report_count: Option<i64> = None;
        let mut field_labeled_record_count: Option<i64> = None;
        let mut field_labeled_account_count: Option<i64> = None;
        let mut field_reported_record_count: Option<i64> = None;
        let mut field_reported_account_count: Option<i64> = None;
        let mut field_takendown_record_count: Option<i64> = None;
        let mut field_takendown_account_count: Option<i64> = 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()));
                    }
                }
                "recordReportCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_record_report_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_record_report_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "accountReportCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_account_report_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_account_report_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "labeledRecordCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_labeled_record_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_labeled_record_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "labeledAccountCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_labeled_account_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_labeled_account_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "reportedRecordCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_reported_record_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_reported_record_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "reportedAccountCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_reported_account_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_reported_account_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "takendownRecordCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_takendown_record_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_takendown_record_count = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "takendownAccountCount" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_takendown_account_count = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_takendown_account_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(ModerationDefsReporterStats {
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            record_report_count: field_record_report_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'recordReportCount'".into(),
                )
            })?,
            account_report_count: field_account_report_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'accountReportCount'".into(),
                )
            })?,
            labeled_record_count: field_labeled_record_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'labeledRecordCount'".into(),
                )
            })?,
            labeled_account_count: field_labeled_account_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'labeledAccountCount'".into(),
                )
            })?,
            reported_record_count: field_reported_record_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'reportedRecordCount'".into(),
                )
            })?,
            reported_account_count: field_reported_account_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'reportedAccountCount'".into(),
                )
            })?,
            takendown_record_count: field_takendown_record_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'takendownRecordCount'".into(),
                )
            })?,
            takendown_account_count: field_takendown_account_count.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor(
                    "missing required field 'takendownAccountCount'".into(),
                )
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// Moderator review status of a subject: Closed. Indicates that the subject was already reviewed and resolved by a moderator
pub const MODERATION_DEFS_REVIEW_CLOSED: &str = "tools.ozone.moderation.defs#reviewClosed";

/// Moderator review status of a subject: Escalated. Indicates that the subject was escalated for review by a moderator
pub const MODERATION_DEFS_REVIEW_ESCALATED: &str = "tools.ozone.moderation.defs#reviewEscalated";

/// Moderator review status of a subject: Unnecessary. Indicates that the subject does not need a review at the moment but there is probably some moderation related metadata available for it
pub const MODERATION_DEFS_REVIEW_NONE: &str = "tools.ozone.moderation.defs#reviewNone";

/// Moderator review status of a subject: Open. Indicates that the subject needs to be reviewed by a moderator
pub const MODERATION_DEFS_REVIEW_OPEN: &str = "tools.ozone.moderation.defs#reviewOpen";

/// ModerationDefsRevokeAccountCredentialsEvent — Account credentials revocation by moderators. Only works on DID subjects.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsRevokeAccountCredentialsEvent {
    /// Comment describing the reason for the revocation.
    pub comment: 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 ModerationDefsRevokeAccountCredentialsEvent {
    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("comment")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.comment)?;
        } 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.comment)?;
                pairs.push(("comment", 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_comment: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

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

/// ModerationDefsScheduleTakedownEvent — Logs a scheduled takedown action for an account.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsScheduleTakedownEvent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execute_after: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execute_at: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execute_until: Option<crate::syntax::Datetime>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsScheduleTakedownEvent {
    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.comment.is_some() {
                count += 1;
            }
            if self.execute_at.is_some() {
                count += 1;
            }
            if self.execute_after.is_some() {
                count += 1;
            }
            if self.execute_until.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.execute_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("executeAt")?;
                if let Some(ref val) = self.execute_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.execute_after.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("executeAfter")?;
                if let Some(ref val) = self.execute_after {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.execute_until.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("executeUntil")?;
                if let Some(ref val) = self.execute_until {
                    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.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            if self.execute_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.execute_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("executeAt", vbuf));
            }
            if self.execute_after.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.execute_after {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("executeAfter", vbuf));
            }
            if self.execute_until.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.execute_until {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("executeUntil", 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_comment: Option<String> = None;
        let mut field_execute_at: Option<crate::syntax::Datetime> = None;
        let mut field_execute_after: Option<crate::syntax::Datetime> = None;
        let mut field_execute_until: Option<crate::syntax::Datetime> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "executeAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_execute_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()));
                    }
                }
                "executeAfter" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_execute_after = 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()));
                    }
                }
                "executeUntil" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_execute_until = 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(ModerationDefsScheduleTakedownEvent {
            comment: field_comment,
            execute_at: field_execute_at,
            execute_after: field_execute_after,
            execute_until: field_execute_until,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsScheduledActionView — View of a scheduled moderation action
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsScheduledActionView {
    /// Type of action to be executed
    pub action: String,
    /// When the scheduled action was created
    pub created_at: crate::syntax::Datetime,
    /// DID of the user who created this scheduled action
    pub created_by: crate::syntax::Did,
    /// Subject DID for the action
    pub did: crate::syntax::Did,
    /// Serialized event object that will be propagated to the event when performed
    pub event_data: serde_json::Value,
    /// Earliest time to execute the action (for randomized scheduling)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execute_after: Option<crate::syntax::Datetime>,
    /// Exact time to execute the action
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execute_at: Option<crate::syntax::Datetime>,
    /// Latest time to execute the action (for randomized scheduling)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execute_until: Option<crate::syntax::Datetime>,
    /// ID of the moderation event created when action was successfully executed
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_event_id: Option<i64>,
    /// Auto-incrementing row ID
    pub id: i64,
    /// When the action was last attempted to be executed
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_executed_at: Option<crate::syntax::Datetime>,
    /// Reason for the last execution failure
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_failure_reason: Option<String>,
    /// Whether execution time should be randomized within the specified range
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub randomize_execution: Option<bool>,
    /// Current status of the scheduled action
    pub status: String,
    /// When the scheduled action was last updated
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<crate::syntax::Datetime>,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsScheduledActionView {
    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.execute_at.is_some() {
                count += 1;
            }
            if self.updated_at.is_some() {
                count += 1;
            }
            if self.execute_after.is_some() {
                count += 1;
            }
            if self.execute_until.is_some() {
                count += 1;
            }
            if self.last_executed_at.is_some() {
                count += 1;
            }
            if self.execution_event_id.is_some() {
                count += 1;
            }
            if self.last_failure_reason.is_some() {
                count += 1;
            }
            if self.randomize_execution.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("id")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.id)?;
            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("action")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.action)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("status")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.status)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdBy")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_by.as_str())?;
            if self.execute_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("executeAt")?;
                if let Some(ref val) = self.execute_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.updated_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("updatedAt")?;
                if let Some(ref val) = self.updated_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.execute_after.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("executeAfter")?;
                if let Some(ref val) = self.execute_after {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.execute_until.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("executeUntil")?;
                if let Some(ref val) = self.execute_until {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.last_executed_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastExecutedAt")?;
                if let Some(ref val) = self.last_executed_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.execution_event_id.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("executionEventId")?;
                if let Some(ref val) = self.execution_event_id {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.last_failure_reason.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastFailureReason")?;
                if let Some(ref val) = self.last_failure_reason {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.randomize_execution.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("randomizeExecution")?;
                if let Some(ref val) = self.randomize_execution {
                    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_i64(self.id)?;
                pairs.push(("id", 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.action)?;
                pairs.push(("action", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.status)?;
                pairs.push(("status", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_by.as_str())?;
                pairs.push(("createdBy", vbuf));
            }
            if self.execute_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.execute_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("executeAt", vbuf));
            }
            if self.updated_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.updated_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("updatedAt", vbuf));
            }
            if self.execute_after.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.execute_after {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("executeAfter", vbuf));
            }
            if self.execute_until.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.execute_until {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("executeUntil", vbuf));
            }
            if self.last_executed_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_executed_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("lastExecutedAt", vbuf));
            }
            if self.execution_event_id.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.execution_event_id {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("executionEventId", vbuf));
            }
            if self.last_failure_reason.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_failure_reason {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("lastFailureReason", vbuf));
            }
            if self.randomize_execution.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.randomize_execution {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("randomizeExecution", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

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

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

        let mut field_id: Option<i64> = None;
        let mut field_did: Option<crate::syntax::Did> = None;
        let mut field_action: Option<String> = None;
        let mut field_status: Option<String> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_created_by: Option<crate::syntax::Did> = None;
        let mut field_execute_at: Option<crate::syntax::Datetime> = None;
        let mut field_updated_at: Option<crate::syntax::Datetime> = None;
        let mut field_execute_after: Option<crate::syntax::Datetime> = None;
        let mut field_execute_until: Option<crate::syntax::Datetime> = None;
        let mut field_last_executed_at: Option<crate::syntax::Datetime> = None;
        let mut field_execution_event_id: Option<i64> = None;
        let mut field_last_failure_reason: Option<String> = None;
        let mut field_randomize_execution: Option<bool> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "id" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_id = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_id = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".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()));
                    }
                }
                "action" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_action = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "status" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_status = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "createdBy" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_by = 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()));
                    }
                }
                "executeAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_execute_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()));
                    }
                }
                "updatedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_updated_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()));
                    }
                }
                "executeAfter" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_execute_after = 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()));
                    }
                }
                "executeUntil" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_execute_until = 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()));
                    }
                }
                "lastExecutedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_last_executed_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()));
                    }
                }
                "executionEventId" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_execution_event_id = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_execution_event_id = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "lastFailureReason" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_last_failure_reason = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "randomizeExecution" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_randomize_execution = 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(ModerationDefsScheduledActionView {
            id: field_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'id'".into())
            })?,
            did: field_did.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'did'".into())
            })?,
            action: field_action.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'action'".into())
            })?,
            status: field_status.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'status'".into())
            })?,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            created_by: field_created_by.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdBy'".into())
            })?,
            event_data: Default::default(),
            execute_at: field_execute_at,
            updated_at: field_updated_at,
            execute_after: field_execute_after,
            execute_until: field_execute_until,
            last_executed_at: field_last_executed_at,
            execution_event_id: field_execution_event_id,
            last_failure_reason: field_last_failure_reason,
            randomize_execution: field_randomize_execution,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsSubjectReviewState is a string type from tools.ozone.moderation.defs.
pub type ModerationDefsSubjectReviewState = String;

/// ModerationDefsSubjectStatusView object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsSubjectStatusView {
    /// Statistics related to the account subject
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account_stats: Option<ModerationDefsAccountStats>,
    /// Strike information for the account (account-level only)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account_strike: Option<ModerationDefsAccountStrike>,
    /// Current age assurance state of the subject.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub age_assurance_state: Option<String>,
    /// Whether or not the last successful update to age assurance was made by the user or admin.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub age_assurance_updated_by: Option<String>,
    /// True indicates that the a previously taken moderator action was appealed against, by the author of the content. False indicates last appeal was resolved by moderators.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub appealed: Option<bool>,
    /// Sticky comment on the subject.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// Timestamp referencing the first moderation status impacting event was emitted on the subject
    pub created_at: crate::syntax::Datetime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hosting: Option<ModerationDefsSubjectStatusViewHostingUnion>,
    pub id: i64,
    /// Timestamp referencing when the author of the subject appealed a moderation action
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_appealed_at: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_reported_at: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_reviewed_at: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_reviewed_by: Option<crate::syntax::Did>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mute_reporting_until: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mute_until: Option<crate::syntax::Datetime>,
    /// Numeric value representing the level of priority. Higher score means higher priority.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub priority_score: Option<i64>,
    /// Statistics related to the record subjects authored by the subject's account
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub records_stats: Option<ModerationDefsRecordsStats>,
    pub review_state: ModerationDefsSubjectReviewState,
    pub subject: ModerationDefsSubjectStatusViewSubjectUnion,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub subject_blob_cids: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subject_repo_handle: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub suspend_until: Option<crate::syntax::Datetime>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub tags: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub takendown: Option<bool>,
    /// Timestamp referencing when the last update was made to the moderation status of the subject
    pub updated_at: crate::syntax::Datetime,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

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

impl serde::Serialize for ModerationDefsSubjectStatusViewHostingUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ModerationDefsSubjectStatusViewHostingUnion::ModerationDefsAccountHosting(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(
                            "tools.ozone.moderation.defs#accountHosting".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsSubjectStatusViewHostingUnion::ModerationDefsRecordHosting(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(
                            "tools.ozone.moderation.defs#recordHosting".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsSubjectStatusViewHostingUnion::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 ModerationDefsSubjectStatusViewHostingUnion {
    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 {
            "tools.ozone.moderation.defs#accountHosting" => {
                let inner: ModerationDefsAccountHosting =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsSubjectStatusViewHostingUnion::ModerationDefsAccountHosting(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#recordHosting" => {
                let inner: ModerationDefsRecordHosting =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsSubjectStatusViewHostingUnion::ModerationDefsRecordHosting(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(ModerationDefsSubjectStatusViewHostingUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ModerationDefsSubjectStatusViewHostingUnion {
    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 {
            ModerationDefsSubjectStatusViewHostingUnion::ModerationDefsAccountHosting(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsSubjectStatusViewHostingUnion::ModerationDefsRecordHosting(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsSubjectStatusViewHostingUnion::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 {
            "tools.ozone.moderation.defs#accountHosting" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsAccountHosting::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsSubjectStatusViewHostingUnion::ModerationDefsAccountHosting(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#recordHosting" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationDefsRecordHosting::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsSubjectStatusViewHostingUnion::ModerationDefsRecordHosting(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(ModerationDefsSubjectStatusViewHostingUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

/// ModerationDefsSubjectStatusViewSubjectUnion is a union type.
#[derive(Debug, Clone)]
pub enum ModerationDefsSubjectStatusViewSubjectUnion {
    AdminDefsRepoRef(Box<crate::api::com::atproto::AdminDefsRepoRef>),
    RepoStrongRef(Box<crate::api::com::atproto::RepoStrongRef>),
    ConvoDefsMessageRef(Box<crate::api::chat::bsky::ConvoDefsMessageRef>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for ModerationDefsSubjectStatusViewSubjectUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ModerationDefsSubjectStatusViewSubjectUnion::AdminDefsRepoRef(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("com.atproto.admin.defs#repoRef".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsSubjectStatusViewSubjectUnion::RepoStrongRef(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("com.atproto.repo.strongRef".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsSubjectStatusViewSubjectUnion::ConvoDefsMessageRef(inner) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String("chat.bsky.convo.defs#messageRef".to_string()),
                    );
                }
                map.serialize(serializer)
            }
            ModerationDefsSubjectStatusViewSubjectUnion::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 ModerationDefsSubjectStatusViewSubjectUnion {
    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 {
            "com.atproto.admin.defs#repoRef" => {
                let inner: crate::api::com::atproto::AdminDefsRepoRef =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsSubjectStatusViewSubjectUnion::AdminDefsRepoRef(Box::new(inner)))
            }
            "com.atproto.repo.strongRef" => {
                let inner: crate::api::com::atproto::RepoStrongRef =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(ModerationDefsSubjectStatusViewSubjectUnion::RepoStrongRef(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#messageRef" => {
                let inner: crate::api::chat::bsky::ConvoDefsMessageRef =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    ModerationDefsSubjectStatusViewSubjectUnion::ConvoDefsMessageRef(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ModerationDefsSubjectStatusViewSubjectUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ModerationDefsSubjectStatusViewSubjectUnion {
    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 {
            ModerationDefsSubjectStatusViewSubjectUnion::AdminDefsRepoRef(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsSubjectStatusViewSubjectUnion::RepoStrongRef(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsSubjectStatusViewSubjectUnion::ConvoDefsMessageRef(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationDefsSubjectStatusViewSubjectUnion::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 {
            "com.atproto.admin.defs#repoRef" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::com::atproto::AdminDefsRepoRef::decode_cbor(&mut dec)?;
                Ok(ModerationDefsSubjectStatusViewSubjectUnion::AdminDefsRepoRef(Box::new(inner)))
            }
            "com.atproto.repo.strongRef" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::com::atproto::RepoStrongRef::decode_cbor(&mut dec)?;
                Ok(ModerationDefsSubjectStatusViewSubjectUnion::RepoStrongRef(
                    Box::new(inner),
                ))
            }
            "chat.bsky.convo.defs#messageRef" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::chat::bsky::ConvoDefsMessageRef::decode_cbor(&mut dec)?;
                Ok(
                    ModerationDefsSubjectStatusViewSubjectUnion::ConvoDefsMessageRef(Box::new(
                        inner,
                    )),
                )
            }
            _ => Ok(ModerationDefsSubjectStatusViewSubjectUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

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

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 5u64;
            if !self.tags.is_empty() {
                count += 1;
            }
            if self.comment.is_some() {
                count += 1;
            }
            if self.hosting.is_some() {
                count += 1;
            }
            if self.appealed.is_some() {
                count += 1;
            }
            if self.mute_until.is_some() {
                count += 1;
            }
            if self.takendown.is_some() {
                count += 1;
            }
            if self.account_stats.is_some() {
                count += 1;
            }
            if self.records_stats.is_some() {
                count += 1;
            }
            if self.suspend_until.is_some() {
                count += 1;
            }
            if self.account_strike.is_some() {
                count += 1;
            }
            if self.priority_score.is_some() {
                count += 1;
            }
            if self.last_appealed_at.is_some() {
                count += 1;
            }
            if self.last_reported_at.is_some() {
                count += 1;
            }
            if self.last_reviewed_at.is_some() {
                count += 1;
            }
            if self.last_reviewed_by.is_some() {
                count += 1;
            }
            if !self.subject_blob_cids.is_empty() {
                count += 1;
            }
            if self.age_assurance_state.is_some() {
                count += 1;
            }
            if self.subject_repo_handle.is_some() {
                count += 1;
            }
            if self.mute_reporting_until.is_some() {
                count += 1;
            }
            if self.age_assurance_updated_by.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("id")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.id)?;
            if !self.tags.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("tags")?;
                crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.tags.len() as u64)?;
                for item in &self.tags {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
                }
            }
            if self.comment.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("comment")?;
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.hosting.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("hosting")?;
                if let Some(ref val) = self.hosting {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("subject")?;
            self.subject.encode_cbor(buf)?;
            if self.appealed.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("appealed")?;
                if let Some(ref val) = self.appealed {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
            if self.mute_until.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("muteUntil")?;
                if let Some(ref val) = self.mute_until {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.takendown.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("takendown")?;
                if let Some(ref val) = self.takendown {
                    crate::cbor::Encoder::new(&mut *buf).encode_bool(*val)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("updatedAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.updated_at.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("reviewState")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.review_state)?;
            if self.account_stats.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("accountStats")?;
                if let Some(ref val) = self.account_stats {
                    val.encode_cbor(buf)?;
                }
            }
            if self.records_stats.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("recordsStats")?;
                if let Some(ref val) = self.records_stats {
                    val.encode_cbor(buf)?;
                }
            }
            if self.suspend_until.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("suspendUntil")?;
                if let Some(ref val) = self.suspend_until {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.account_strike.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("accountStrike")?;
                if let Some(ref val) = self.account_strike {
                    val.encode_cbor(buf)?;
                }
            }
            if self.priority_score.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("priorityScore")?;
                if let Some(ref val) = self.priority_score {
                    crate::cbor::Encoder::new(&mut *buf).encode_i64(*val)?;
                }
            }
            if self.last_appealed_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastAppealedAt")?;
                if let Some(ref val) = self.last_appealed_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.last_reported_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastReportedAt")?;
                if let Some(ref val) = self.last_reported_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.last_reviewed_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastReviewedAt")?;
                if let Some(ref val) = self.last_reviewed_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.last_reviewed_by.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("lastReviewedBy")?;
                if let Some(ref val) = self.last_reviewed_by {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if !self.subject_blob_cids.is_empty() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("subjectBlobCids")?;
                crate::cbor::Encoder::new(&mut *buf)
                    .encode_array_header(self.subject_blob_cids.len() as u64)?;
                for item in &self.subject_blob_cids {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(item)?;
                }
            }
            if self.age_assurance_state.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("ageAssuranceState")?;
                if let Some(ref val) = self.age_assurance_state {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.subject_repo_handle.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("subjectRepoHandle")?;
                if let Some(ref val) = self.subject_repo_handle {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.mute_reporting_until.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("muteReportingUntil")?;
                if let Some(ref val) = self.mute_reporting_until {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.age_assurance_updated_by.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("ageAssuranceUpdatedBy")?;
                if let Some(ref val) = self.age_assurance_updated_by {
                    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_i64(self.id)?;
                pairs.push(("id", vbuf));
            }
            if !self.tags.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_array_header(self.tags.len() as u64)?;
                for item in &self.tags {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("tags", vbuf));
            }
            if self.comment.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.comment {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("comment", vbuf));
            }
            if self.hosting.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.hosting {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("hosting", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                self.subject.encode_cbor(&mut vbuf)?;
                pairs.push(("subject", vbuf));
            }
            if self.appealed.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.appealed {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("appealed", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            if self.mute_until.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.mute_until {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("muteUntil", vbuf));
            }
            if self.takendown.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.takendown {
                    crate::cbor::Encoder::new(&mut vbuf).encode_bool(*val)?;
                }
                pairs.push(("takendown", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.updated_at.as_str())?;
                pairs.push(("updatedAt", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.review_state)?;
                pairs.push(("reviewState", vbuf));
            }
            if self.account_stats.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.account_stats {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("accountStats", vbuf));
            }
            if self.records_stats.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.records_stats {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("recordsStats", vbuf));
            }
            if self.suspend_until.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.suspend_until {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("suspendUntil", vbuf));
            }
            if self.account_strike.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.account_strike {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("accountStrike", vbuf));
            }
            if self.priority_score.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.priority_score {
                    crate::cbor::Encoder::new(&mut vbuf).encode_i64(*val)?;
                }
                pairs.push(("priorityScore", vbuf));
            }
            if self.last_appealed_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_appealed_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("lastAppealedAt", vbuf));
            }
            if self.last_reported_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_reported_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("lastReportedAt", vbuf));
            }
            if self.last_reviewed_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_reviewed_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("lastReviewedAt", vbuf));
            }
            if self.last_reviewed_by.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.last_reviewed_by {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("lastReviewedBy", vbuf));
            }
            if !self.subject_blob_cids.is_empty() {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.subject_blob_cids.len() as u64)?;
                for item in &self.subject_blob_cids {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item)?;
                }
                pairs.push(("subjectBlobCids", vbuf));
            }
            if self.age_assurance_state.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.age_assurance_state {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("ageAssuranceState", vbuf));
            }
            if self.subject_repo_handle.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.subject_repo_handle {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("subjectRepoHandle", vbuf));
            }
            if self.mute_reporting_until.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.mute_reporting_until {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("muteReportingUntil", vbuf));
            }
            if self.age_assurance_updated_by.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.age_assurance_updated_by {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("ageAssuranceUpdatedBy", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

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

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

        let mut field_id: Option<i64> = None;
        let mut field_tags: Vec<String> = Vec::new();
        let mut field_comment: Option<String> = None;
        let mut field_hosting: Option<ModerationDefsSubjectStatusViewHostingUnion> = None;
        let mut field_subject: Option<ModerationDefsSubjectStatusViewSubjectUnion> = None;
        let mut field_appealed: Option<bool> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_mute_until: Option<crate::syntax::Datetime> = None;
        let mut field_takendown: Option<bool> = None;
        let mut field_updated_at: Option<crate::syntax::Datetime> = None;
        let mut field_review_state: Option<ModerationDefsSubjectReviewState> = None;
        let mut field_account_stats: Option<ModerationDefsAccountStats> = None;
        let mut field_records_stats: Option<ModerationDefsRecordsStats> = None;
        let mut field_suspend_until: Option<crate::syntax::Datetime> = None;
        let mut field_account_strike: Option<ModerationDefsAccountStrike> = None;
        let mut field_priority_score: Option<i64> = None;
        let mut field_last_appealed_at: Option<crate::syntax::Datetime> = None;
        let mut field_last_reported_at: Option<crate::syntax::Datetime> = None;
        let mut field_last_reviewed_at: Option<crate::syntax::Datetime> = None;
        let mut field_last_reviewed_by: Option<crate::syntax::Did> = None;
        let mut field_subject_blob_cids: Vec<String> = Vec::new();
        let mut field_age_assurance_state: Option<String> = None;
        let mut field_subject_repo_handle: Option<String> = None;
        let mut field_mute_reporting_until: Option<crate::syntax::Datetime> = None;
        let mut field_age_assurance_updated_by: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "id" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_id = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_id = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "tags" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_tags.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "comment" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_comment = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "hosting" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_hosting = Some(ModerationDefsSubjectStatusViewHostingUnion::decode_cbor(
                        &mut dec,
                    )?);
                }
                "subject" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_subject = Some(ModerationDefsSubjectStatusViewSubjectUnion::decode_cbor(
                        &mut dec,
                    )?);
                }
                "appealed" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_appealed = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "muteUntil" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_mute_until = 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()));
                    }
                }
                "takendown" => {
                    if let crate::cbor::Value::Bool(b) = value {
                        field_takendown = Some(b);
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected bool".into()));
                    }
                }
                "updatedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_updated_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()));
                    }
                }
                "reviewState" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_review_state = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "accountStats" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_account_stats = Some(ModerationDefsAccountStats::decode_cbor(&mut dec)?);
                }
                "recordsStats" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_records_stats = Some(ModerationDefsRecordsStats::decode_cbor(&mut dec)?);
                }
                "suspendUntil" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_suspend_until = 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()));
                    }
                }
                "accountStrike" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_account_strike =
                        Some(ModerationDefsAccountStrike::decode_cbor(&mut dec)?);
                }
                "priorityScore" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_priority_score = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_priority_score = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "lastAppealedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_last_appealed_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()));
                    }
                }
                "lastReportedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_last_reported_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()));
                    }
                }
                "lastReviewedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_last_reviewed_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()));
                    }
                }
                "lastReviewedBy" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_last_reviewed_by = 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()));
                    }
                }
                "subjectBlobCids" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_subject_blob_cids.push(s.to_string());
                            } else {
                                return Err(crate::cbor::CborError::InvalidCbor(
                                    "expected text in array".into(),
                                ));
                            }
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "ageAssuranceState" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_age_assurance_state = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "subjectRepoHandle" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_subject_repo_handle = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "muteReportingUntil" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_mute_reporting_until = 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()));
                    }
                }
                "ageAssuranceUpdatedBy" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_age_assurance_updated_by = 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(ModerationDefsSubjectStatusView {
            id: field_id.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'id'".into())
            })?,
            tags: field_tags,
            comment: field_comment,
            hosting: field_hosting,
            subject: field_subject.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'subject'".into())
            })?,
            appealed: field_appealed,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            mute_until: field_mute_until,
            takendown: field_takendown,
            updated_at: field_updated_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'updatedAt'".into())
            })?,
            review_state: field_review_state.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'reviewState'".into())
            })?,
            account_stats: field_account_stats,
            records_stats: field_records_stats,
            suspend_until: field_suspend_until,
            account_strike: field_account_strike,
            priority_score: field_priority_score,
            last_appealed_at: field_last_appealed_at,
            last_reported_at: field_last_reported_at,
            last_reviewed_at: field_last_reviewed_at,
            last_reviewed_by: field_last_reviewed_by,
            subject_blob_cids: field_subject_blob_cids,
            age_assurance_state: field_age_assurance_state,
            subject_repo_handle: field_subject_repo_handle,
            mute_reporting_until: field_mute_reporting_until,
            age_assurance_updated_by: field_age_assurance_updated_by,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationDefsSubjectView — Detailed view of a subject. For record subjects, the author's repo and profile will be returned.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsSubjectView {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub profile: Option<ModerationDefsSubjectViewProfileUnion>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub record: Option<ModerationDefsRecordViewDetail>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repo: Option<ModerationDefsRepoViewDetail>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<ModerationDefsSubjectStatusView>,
    pub subject: String,
    pub r#type: crate::api::com::atproto::ModerationDefsSubjectType,
    /// 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>)>,
}

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

impl serde::Serialize for ModerationDefsSubjectViewProfileUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            ModerationDefsSubjectViewProfileUnion::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 ModerationDefsSubjectViewProfileUnion {
    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 {
            _ => Ok(ModerationDefsSubjectViewProfileUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl ModerationDefsSubjectViewProfileUnion {
    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 {
            ModerationDefsSubjectViewProfileUnion::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 {
            _ => Ok(ModerationDefsSubjectViewProfileUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

impl ModerationDefsSubjectView {
    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.repo.is_some() {
                count += 1;
            }
            if self.record.is_some() {
                count += 1;
            }
            if self.status.is_some() {
                count += 1;
            }
            if self.profile.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            if self.repo.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("repo")?;
                if let Some(ref val) = self.repo {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("type")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.r#type)?;
            if self.record.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("record")?;
                if let Some(ref val) = self.record {
                    val.encode_cbor(buf)?;
                }
            }
            if self.status.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("status")?;
                if let Some(ref val) = self.status {
                    val.encode_cbor(buf)?;
                }
            }
            if self.profile.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("profile")?;
                if let Some(ref val) = self.profile {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("subject")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.subject)?;
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            if self.repo.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.repo {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("repo", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.r#type)?;
                pairs.push(("type", vbuf));
            }
            if self.record.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.record {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("record", vbuf));
            }
            if self.status.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.status {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("status", vbuf));
            }
            if self.profile.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.profile {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("profile", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.subject)?;
                pairs.push(("subject", 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_repo: Option<ModerationDefsRepoViewDetail> = None;
        let mut field_type: Option<crate::api::com::atproto::ModerationDefsSubjectType> = None;
        let mut field_record: Option<ModerationDefsRecordViewDetail> = None;
        let mut field_status: Option<ModerationDefsSubjectStatusView> = None;
        let mut field_profile: Option<ModerationDefsSubjectViewProfileUnion> = None;
        let mut field_subject: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "repo" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_repo = Some(ModerationDefsRepoViewDetail::decode_cbor(&mut dec)?);
                }
                "type" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_type = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "record" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_record = Some(ModerationDefsRecordViewDetail::decode_cbor(&mut dec)?);
                }
                "status" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_status = Some(ModerationDefsSubjectStatusView::decode_cbor(&mut dec)?);
                }
                "profile" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_profile = Some(ModerationDefsSubjectViewProfileUnion::decode_cbor(
                        &mut dec,
                    )?);
                }
                "subject" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_subject = 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(ModerationDefsSubjectView {
            repo: field_repo,
            r#type: field_type.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'type'".into())
            })?,
            record: field_record,
            status: field_status,
            profile: field_profile,
            subject: field_subject.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'subject'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// Moderation event timeline event for a PLC create operation
pub const MODERATION_DEFS_TIMELINE_EVENT_PLC_CREATE: &str =
    "tools.ozone.moderation.defs#timelineEventPlcCreate";

/// Moderation event timeline event for generic PLC operation
pub const MODERATION_DEFS_TIMELINE_EVENT_PLC_OPERATION: &str =
    "tools.ozone.moderation.defs#timelineEventPlcOperation";

/// Moderation event timeline event for a PLC tombstone operation
pub const MODERATION_DEFS_TIMELINE_EVENT_PLC_TOMBSTONE: &str =
    "tools.ozone.moderation.defs#timelineEventPlcTombstone";

/// ModerationDefsVideoDetails object from tools.ozone.moderation.defs.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationDefsVideoDetails {
    pub height: i64,
    pub length: i64,
    pub width: i64,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

impl ModerationDefsVideoDetails {
    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("width")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.width)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("height")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.height)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("length")?;
            crate::cbor::Encoder::new(&mut *buf).encode_i64(self.length)?;
        } 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_i64(self.width)?;
                pairs.push(("width", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.height)?;
                pairs.push(("height", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_i64(self.length)?;
                pairs.push(("length", 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_width: Option<i64> = None;
        let mut field_height: Option<i64> = None;
        let mut field_length: Option<i64> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "width" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_width = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_width = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "height" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_height = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_height = Some(n);
                    }
                    _ => {
                        return Err(crate::cbor::CborError::InvalidCbor(
                            "expected integer".into(),
                        ));
                    }
                },
                "length" => match value {
                    crate::cbor::Value::Unsigned(n) => {
                        field_length = Some(n as i64);
                    }
                    crate::cbor::Value::Signed(n) => {
                        field_length = 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(ModerationDefsVideoDetails {
            width: field_width.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'width'".into())
            })?,
            height: field_height.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'height'".into())
            })?,
            length: field_length.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'length'".into())
            })?,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}