shrike 0.1.1

// Code generated by lexgen. DO NOT EDIT.

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

impl ModerationScheduleActionFailedScheduling {
    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.error_code.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("error")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.error)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("subject")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.subject.as_str())?;
            if self.error_code.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("errorCode")?;
                if let Some(ref val) = self.error_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();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.error)?;
                pairs.push(("error", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.subject.as_str())?;
                pairs.push(("subject", vbuf));
            }
            if self.error_code.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.error_code {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("errorCode", 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_error: Option<String> = None;
        let mut field_subject: Option<crate::syntax::Did> = None;
        let mut field_error_code: Option<String> = None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "error" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_error = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "subject" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_subject = Some(
                            crate::syntax::Did::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "errorCode" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_error_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(ModerationScheduleActionFailedScheduling {
            error: field_error.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'error'".into())
            })?,
            subject: field_subject.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'subject'".into())
            })?,
            error_code: field_error_code,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationScheduleActionInput {
    pub action: ModerationScheduleActionInputActionUnion,
    pub created_by: crate::syntax::Did,
    /// This will be propagated to the moderation event when it is applied
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mod_tool: Option<crate::api::tools::ozone::ModerationDefsModTool>,
    pub scheduling: ModerationScheduleActionSchedulingConfig,
    /// Array of DID subjects to schedule the action for
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub subjects: Vec<crate::syntax::Did>,
    /// Extra fields not defined in the schema.
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
}

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

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

impl ModerationScheduleActionInputActionUnion {
    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 {
            ModerationScheduleActionInputActionUnion::ModerationScheduleActionTakedown(inner) => {
                inner.encode_cbor(buf)
            }
            ModerationScheduleActionInputActionUnion::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.scheduleAction#takedown" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = ModerationScheduleActionTakedown::decode_cbor(&mut dec)?;
                Ok(
                    ModerationScheduleActionInputActionUnion::ModerationScheduleActionTakedown(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(ModerationScheduleActionInputActionUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

/// ModerationScheduleActionOutput is an alias.
pub type ModerationScheduleActionOutput = ModerationScheduleActionScheduledActionResults;

/// ModerationScheduleAction — Schedule a moderation action to be executed at a future time
pub async fn moderation_schedule_action(
    client: &crate::xrpc::Client,
    input: &ModerationScheduleActionInput,
) -> Result<ModerationScheduleActionOutput, crate::xrpc::Error> {
    client
        .procedure("tools.ozone.moderation.scheduleAction", input)
        .await
}

/// ModerationScheduleActionScheduledActionResults object from tools.ozone.moderation.scheduleAction.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationScheduleActionScheduledActionResults {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub failed: Vec<ModerationScheduleActionFailedScheduling>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub succeeded: Vec<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 ModerationScheduleActionScheduledActionResults {
    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("failed")?;
            crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.failed.len() as u64)?;
            for item in &self.failed {
                item.encode_cbor(buf)?;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("succeeded")?;
            crate::cbor::Encoder::new(&mut *buf).encode_array_header(self.succeeded.len() as u64)?;
            for item in &self.succeeded {
                crate::cbor::Encoder::new(&mut *buf).encode_text(item.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_array_header(self.failed.len() as u64)?;
                for item in &self.failed {
                    item.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("failed", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf)
                    .encode_array_header(self.succeeded.len() as u64)?;
                for item in &self.succeeded {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(item.as_str())?;
                }
                pairs.push(("succeeded", 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_failed: Vec<ModerationScheduleActionFailedScheduling> = Vec::new();
        let mut field_succeeded: Vec<crate::syntax::Did> = Vec::new();
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "failed" => {
                    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_failed.push(
                                ModerationScheduleActionFailedScheduling::decode_cbor(&mut dec)?,
                            );
                        }
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected array".into()));
                    }
                }
                "succeeded" => {
                    if let crate::cbor::Value::Array(items) = value {
                        for item in items {
                            if let crate::cbor::Value::Text(s) = item {
                                field_succeeded.push(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 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(ModerationScheduleActionScheduledActionResults {
            failed: field_failed,
            succeeded: field_succeeded,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationScheduleActionSchedulingConfig — Configuration for when the action should be executed
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationScheduleActionSchedulingConfig {
    /// 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>,
    /// 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 ModerationScheduleActionSchedulingConfig {
    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.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.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.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_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 {
                "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(ModerationScheduleActionSchedulingConfig {
            execute_at: field_execute_at,
            execute_after: field_execute_after,
            execute_until: field_execute_until,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}

/// ModerationScheduleActionTakedown — Schedule a takedown action
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationScheduleActionTakedown {
    /// 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>,
    /// Email content to be sent to the user upon takedown.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email_content: Option<String>,
    /// Subject of the email to be sent to the user upon takedown.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email_subject: Option<String>,
    /// 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 when takedown is applied.
    #[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>,
    /// 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 ModerationScheduleActionTakedown {
    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.email_content.is_some() {
                count += 1;
            }
            if self.email_subject.is_some() {
                count += 1;
            }
            if self.severity_level.is_some() {
                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.email_content.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("emailContent")?;
                if let Some(ref val) = self.email_content {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.email_subject.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("emailSubject")?;
                if let Some(ref val) = self.email_subject {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(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.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.email_content.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.email_content {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("emailContent", vbuf));
            }
            if self.email_subject.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.email_subject {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("emailSubject", 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.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_email_content: Option<String> = None;
        let mut field_email_subject: Option<String> = None;
        let mut field_severity_level: Option<String> = None;
        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(),
                        ));
                    }
                },
                "emailContent" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_email_content = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "emailSubject" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_email_subject = 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()));
                    }
                }
                "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(ModerationScheduleActionTakedown {
            comment: field_comment,
            policies: field_policies,
            strike_count: field_strike_count,
            email_content: field_email_content,
            email_subject: field_email_subject,
            severity_level: field_severity_level,
            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,
        })
    }
}