#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModerationEmitEventInput {
pub created_by: crate::syntax::Did,
pub event: ModerationEmitEventInputEventUnion,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mod_tool: Option<crate::api::tools::ozone::ModerationDefsModTool>,
pub subject: ModerationEmitEventInputSubjectUnion,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub subject_blob_cids: Vec<String>,
#[serde(flatten)]
pub extra: std::collections::HashMap<String, serde_json::Value>,
}
#[derive(Debug, Clone)]
pub enum ModerationEmitEventInputEventUnion {
ModerationDefsModEventTakedown(Box<crate::api::tools::ozone::ModerationDefsModEventTakedown>),
ModerationDefsModEventAcknowledge(
Box<crate::api::tools::ozone::ModerationDefsModEventAcknowledge>,
),
ModerationDefsModEventEscalate(Box<crate::api::tools::ozone::ModerationDefsModEventEscalate>),
ModerationDefsModEventComment(Box<crate::api::tools::ozone::ModerationDefsModEventComment>),
ModerationDefsModEventLabel(Box<crate::api::tools::ozone::ModerationDefsModEventLabel>),
ModerationDefsModEventReport(Box<crate::api::tools::ozone::ModerationDefsModEventReport>),
ModerationDefsModEventMute(Box<crate::api::tools::ozone::ModerationDefsModEventMute>),
ModerationDefsModEventUnmute(Box<crate::api::tools::ozone::ModerationDefsModEventUnmute>),
ModerationDefsModEventMuteReporter(
Box<crate::api::tools::ozone::ModerationDefsModEventMuteReporter>,
),
ModerationDefsModEventUnmuteReporter(
Box<crate::api::tools::ozone::ModerationDefsModEventUnmuteReporter>,
),
ModerationDefsModEventReverseTakedown(
Box<crate::api::tools::ozone::ModerationDefsModEventReverseTakedown>,
),
ModerationDefsModEventResolveAppeal(
Box<crate::api::tools::ozone::ModerationDefsModEventResolveAppeal>,
),
ModerationDefsModEventEmail(Box<crate::api::tools::ozone::ModerationDefsModEventEmail>),
ModerationDefsModEventDivert(Box<crate::api::tools::ozone::ModerationDefsModEventDivert>),
ModerationDefsModEventTag(Box<crate::api::tools::ozone::ModerationDefsModEventTag>),
ModerationDefsAccountEvent(Box<crate::api::tools::ozone::ModerationDefsAccountEvent>),
ModerationDefsIdentityEvent(Box<crate::api::tools::ozone::ModerationDefsIdentityEvent>),
ModerationDefsRecordEvent(Box<crate::api::tools::ozone::ModerationDefsRecordEvent>),
ModerationDefsModEventPriorityScore(
Box<crate::api::tools::ozone::ModerationDefsModEventPriorityScore>,
),
ModerationDefsAgeAssuranceEvent(Box<crate::api::tools::ozone::ModerationDefsAgeAssuranceEvent>),
ModerationDefsAgeAssuranceOverrideEvent(
Box<crate::api::tools::ozone::ModerationDefsAgeAssuranceOverrideEvent>,
),
ModerationDefsAgeAssurancePurgeEvent(
Box<crate::api::tools::ozone::ModerationDefsAgeAssurancePurgeEvent>,
),
ModerationDefsRevokeAccountCredentialsEvent(
Box<crate::api::tools::ozone::ModerationDefsRevokeAccountCredentialsEvent>,
),
ModerationDefsScheduleTakedownEvent(
Box<crate::api::tools::ozone::ModerationDefsScheduleTakedownEvent>,
),
ModerationDefsCancelScheduledTakedownEvent(
Box<crate::api::tools::ozone::ModerationDefsCancelScheduledTakedownEvent>,
),
Unknown(crate::api::UnknownUnionVariant),
}
impl serde::Serialize for ModerationEmitEventInputEventUnion {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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)
}
ModerationEmitEventInputEventUnion::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 ModerationEmitEventInputEventUnion {
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: crate::api::tools::ozone::ModerationDefsModEventTakedown =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventTakedown(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventAcknowledge" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventAcknowledge =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventAcknowledge(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventEscalate" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventEscalate =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventEscalate(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventComment" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventComment =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventComment(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventLabel" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventLabel =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventLabel(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventReport" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventReport =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventReport(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventMute" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventMute =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ModerationEmitEventInputEventUnion::ModerationDefsModEventMute(Box::new(inner)))
}
"tools.ozone.moderation.defs#modEventUnmute" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventUnmute =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventUnmute(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventMuteReporter" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventMuteReporter =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventMuteReporter(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventUnmuteReporter" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventUnmuteReporter =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventUnmuteReporter(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventReverseTakedown" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventReverseTakedown =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventReverseTakedown(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventResolveAppeal" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventResolveAppeal =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventResolveAppeal(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventEmail" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventEmail =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventEmail(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventDivert" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventDivert =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventDivert(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventTag" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventTag =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ModerationEmitEventInputEventUnion::ModerationDefsModEventTag(Box::new(inner)))
}
"tools.ozone.moderation.defs#accountEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsAccountEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ModerationEmitEventInputEventUnion::ModerationDefsAccountEvent(Box::new(inner)))
}
"tools.ozone.moderation.defs#identityEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsIdentityEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsIdentityEvent(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#recordEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsRecordEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ModerationEmitEventInputEventUnion::ModerationDefsRecordEvent(Box::new(inner)))
}
"tools.ozone.moderation.defs#modEventPriorityScore" => {
let inner: crate::api::tools::ozone::ModerationDefsModEventPriorityScore =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventPriorityScore(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#ageAssuranceEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsAgeAssuranceEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssuranceEvent(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#ageAssuranceOverrideEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsAgeAssuranceOverrideEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssuranceOverrideEvent(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#ageAssurancePurgeEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsAgeAssurancePurgeEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssurancePurgeEvent(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#revokeAccountCredentialsEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsRevokeAccountCredentialsEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsRevokeAccountCredentialsEvent(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#scheduleTakedownEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsScheduleTakedownEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsScheduleTakedownEvent(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#cancelScheduledTakedownEvent" => {
let inner: crate::api::tools::ozone::ModerationDefsCancelScheduledTakedownEvent =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsCancelScheduledTakedownEvent(
Box::new(inner),
),
)
}
_ => Ok(ModerationEmitEventInputEventUnion::Unknown(
crate::api::UnknownUnionVariant {
r#type: type_str.to_string(),
json: Some(value),
cbor: None,
},
)),
}
}
}
impl ModerationEmitEventInputEventUnion {
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 {
ModerationEmitEventInputEventUnion::ModerationDefsModEventTakedown(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventAcknowledge(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventEscalate(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventComment(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventLabel(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventReport(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventMute(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventUnmute(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventMuteReporter(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventUnmuteReporter(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventReverseTakedown(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventResolveAppeal(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventEmail(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventDivert(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventTag(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsAccountEvent(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsIdentityEvent(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsRecordEvent(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsModEventPriorityScore(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssuranceEvent(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssuranceOverrideEvent(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssurancePurgeEvent(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsRevokeAccountCredentialsEvent(
inner,
) => inner.encode_cbor(buf),
ModerationEmitEventInputEventUnion::ModerationDefsScheduleTakedownEvent(inner) => {
inner.encode_cbor(buf)
}
ModerationEmitEventInputEventUnion::ModerationDefsCancelScheduledTakedownEvent(
inner,
) => inner.encode_cbor(buf),
ModerationEmitEventInputEventUnion::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> {
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 = crate::api::tools::ozone::ModerationDefsModEventTakedown::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventTakedown(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventAcknowledge" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventAcknowledge::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventAcknowledge(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventEscalate" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::tools::ozone::ModerationDefsModEventEscalate::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventEscalate(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventComment" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventComment::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventComment(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventLabel" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventLabel::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventLabel(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventReport" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventReport::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventReport(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventMute" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventMute::decode_cbor(&mut dec)?;
Ok(ModerationEmitEventInputEventUnion::ModerationDefsModEventMute(Box::new(inner)))
}
"tools.ozone.moderation.defs#modEventUnmute" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventUnmute::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventUnmute(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventMuteReporter" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventMuteReporter::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventMuteReporter(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventUnmuteReporter" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventUnmuteReporter::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventUnmuteReporter(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventReverseTakedown" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventReverseTakedown::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventReverseTakedown(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventResolveAppeal" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventResolveAppeal::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventResolveAppeal(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#modEventEmail" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventEmail::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventEmail(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventDivert" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventDivert::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventDivert(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#modEventTag" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventTag::decode_cbor(&mut dec)?;
Ok(ModerationEmitEventInputEventUnion::ModerationDefsModEventTag(Box::new(inner)))
}
"tools.ozone.moderation.defs#accountEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsAccountEvent::decode_cbor(&mut dec)?;
Ok(ModerationEmitEventInputEventUnion::ModerationDefsAccountEvent(Box::new(inner)))
}
"tools.ozone.moderation.defs#identityEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsIdentityEvent::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsIdentityEvent(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#recordEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsRecordEvent::decode_cbor(&mut dec)?;
Ok(ModerationEmitEventInputEventUnion::ModerationDefsRecordEvent(Box::new(inner)))
}
"tools.ozone.moderation.defs#modEventPriorityScore" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsModEventPriorityScore::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsModEventPriorityScore(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#ageAssuranceEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::tools::ozone::ModerationDefsAgeAssuranceEvent::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssuranceEvent(Box::new(
inner,
)),
)
}
"tools.ozone.moderation.defs#ageAssuranceOverrideEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsAgeAssuranceOverrideEvent::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssuranceOverrideEvent(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#ageAssurancePurgeEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsAgeAssurancePurgeEvent::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsAgeAssurancePurgeEvent(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#revokeAccountCredentialsEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::tools::ozone::ModerationDefsRevokeAccountCredentialsEvent::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsRevokeAccountCredentialsEvent(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#scheduleTakedownEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::tools::ozone::ModerationDefsScheduleTakedownEvent::decode_cbor(
&mut dec,
)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsScheduleTakedownEvent(
Box::new(inner),
),
)
}
"tools.ozone.moderation.defs#cancelScheduledTakedownEvent" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::tools::ozone::ModerationDefsCancelScheduledTakedownEvent::decode_cbor(&mut dec)?;
Ok(
ModerationEmitEventInputEventUnion::ModerationDefsCancelScheduledTakedownEvent(
Box::new(inner),
),
)
}
_ => Ok(ModerationEmitEventInputEventUnion::Unknown(
crate::api::UnknownUnionVariant {
r#type: type_str.to_string(),
json: None,
cbor: Some(raw.to_vec()),
},
)),
}
}
}
#[derive(Debug, Clone)]
pub enum ModerationEmitEventInputSubjectUnion {
AdminDefsRepoRef(Box<crate::api::com::atproto::AdminDefsRepoRef>),
RepoStrongRef(Box<crate::api::com::atproto::RepoStrongRef>),
Unknown(crate::api::UnknownUnionVariant),
}
impl serde::Serialize for ModerationEmitEventInputSubjectUnion {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
ModerationEmitEventInputSubjectUnion::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)
}
ModerationEmitEventInputSubjectUnion::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)
}
ModerationEmitEventInputSubjectUnion::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 ModerationEmitEventInputSubjectUnion {
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(ModerationEmitEventInputSubjectUnion::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(ModerationEmitEventInputSubjectUnion::RepoStrongRef(
Box::new(inner),
))
}
_ => Ok(ModerationEmitEventInputSubjectUnion::Unknown(
crate::api::UnknownUnionVariant {
r#type: type_str.to_string(),
json: Some(value),
cbor: None,
},
)),
}
}
}
impl ModerationEmitEventInputSubjectUnion {
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 {
ModerationEmitEventInputSubjectUnion::AdminDefsRepoRef(inner) => inner.encode_cbor(buf),
ModerationEmitEventInputSubjectUnion::RepoStrongRef(inner) => inner.encode_cbor(buf),
ModerationEmitEventInputSubjectUnion::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> {
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(ModerationEmitEventInputSubjectUnion::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(ModerationEmitEventInputSubjectUnion::RepoStrongRef(
Box::new(inner),
))
}
_ => Ok(ModerationEmitEventInputSubjectUnion::Unknown(
crate::api::UnknownUnionVariant {
r#type: type_str.to_string(),
json: None,
cbor: Some(raw.to_vec()),
},
)),
}
}
}
pub type ModerationEmitEventOutput = crate::api::tools::ozone::ModerationDefsModEventView;
pub async fn moderation_emit_event(
client: &crate::xrpc::Client,
input: &ModerationEmitEventInput,
) -> Result<ModerationEmitEventOutput, crate::xrpc::Error> {
client
.procedure("tools.ozone.moderation.emitEvent", input)
.await
}