#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoGetLogParams {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cursor: Option<String>,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConvoGetLogOutput {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cursor: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub logs: Vec<ConvoGetLogOutputLogsUnion>,
#[serde(flatten)]
pub extra: std::collections::HashMap<String, serde_json::Value>,
}
#[derive(Debug, Clone)]
pub enum ConvoGetLogOutputLogsUnion {
ConvoDefsLogBeginConvo(Box<crate::api::chat::bsky::ConvoDefsLogBeginConvo>),
ConvoDefsLogAcceptConvo(Box<crate::api::chat::bsky::ConvoDefsLogAcceptConvo>),
ConvoDefsLogLeaveConvo(Box<crate::api::chat::bsky::ConvoDefsLogLeaveConvo>),
ConvoDefsLogMuteConvo(Box<crate::api::chat::bsky::ConvoDefsLogMuteConvo>),
ConvoDefsLogUnmuteConvo(Box<crate::api::chat::bsky::ConvoDefsLogUnmuteConvo>),
ConvoDefsLogCreateMessage(Box<crate::api::chat::bsky::ConvoDefsLogCreateMessage>),
ConvoDefsLogDeleteMessage(Box<crate::api::chat::bsky::ConvoDefsLogDeleteMessage>),
ConvoDefsLogReadMessage(Box<crate::api::chat::bsky::ConvoDefsLogReadMessage>),
ConvoDefsLogAddReaction(Box<crate::api::chat::bsky::ConvoDefsLogAddReaction>),
ConvoDefsLogRemoveReaction(Box<crate::api::chat::bsky::ConvoDefsLogRemoveReaction>),
Unknown(crate::api::UnknownUnionVariant),
}
impl serde::Serialize for ConvoGetLogOutputLogsUnion {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
ConvoGetLogOutputLogsUnion::ConvoDefsLogBeginConvo(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#logBeginConvo".to_string()),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogAcceptConvo(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#logAcceptConvo".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogLeaveConvo(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#logLeaveConvo".to_string()),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogMuteConvo(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#logMuteConvo".to_string()),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogUnmuteConvo(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#logUnmuteConvo".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogCreateMessage(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#logCreateMessage".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogDeleteMessage(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#logDeleteMessage".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogReadMessage(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#logReadMessage".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogAddReaction(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#logAddReaction".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogRemoveReaction(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#logRemoveReaction".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::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 ConvoGetLogOutputLogsUnion {
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 {
"chat.bsky.convo.defs#logBeginConvo" => {
let inner: crate::api::chat::bsky::ConvoDefsLogBeginConvo =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogBeginConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logAcceptConvo" => {
let inner: crate::api::chat::bsky::ConvoDefsLogAcceptConvo =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogAcceptConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logLeaveConvo" => {
let inner: crate::api::chat::bsky::ConvoDefsLogLeaveConvo =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogLeaveConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logMuteConvo" => {
let inner: crate::api::chat::bsky::ConvoDefsLogMuteConvo =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogMuteConvo(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logUnmuteConvo" => {
let inner: crate::api::chat::bsky::ConvoDefsLogUnmuteConvo =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogUnmuteConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logCreateMessage" => {
let inner: crate::api::chat::bsky::ConvoDefsLogCreateMessage =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogCreateMessage(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logDeleteMessage" => {
let inner: crate::api::chat::bsky::ConvoDefsLogDeleteMessage =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogDeleteMessage(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logReadMessage" => {
let inner: crate::api::chat::bsky::ConvoDefsLogReadMessage =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogReadMessage(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logAddReaction" => {
let inner: crate::api::chat::bsky::ConvoDefsLogAddReaction =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogAddReaction(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logRemoveReaction" => {
let inner: crate::api::chat::bsky::ConvoDefsLogRemoveReaction =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogRemoveReaction(
Box::new(inner),
))
}
_ => Ok(ConvoGetLogOutputLogsUnion::Unknown(
crate::api::UnknownUnionVariant {
r#type: type_str.to_string(),
json: Some(value),
cbor: None,
},
)),
}
}
}
impl ConvoGetLogOutputLogsUnion {
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 {
ConvoGetLogOutputLogsUnion::ConvoDefsLogBeginConvo(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogAcceptConvo(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogLeaveConvo(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogMuteConvo(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogUnmuteConvo(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogCreateMessage(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogDeleteMessage(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogReadMessage(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogAddReaction(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogRemoveReaction(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::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 {
"chat.bsky.convo.defs#logBeginConvo" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogBeginConvo::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogBeginConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logAcceptConvo" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogAcceptConvo::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogAcceptConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logLeaveConvo" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogLeaveConvo::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogLeaveConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logMuteConvo" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogMuteConvo::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogMuteConvo(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logUnmuteConvo" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogUnmuteConvo::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogUnmuteConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logCreateMessage" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogCreateMessage::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogCreateMessage(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logDeleteMessage" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogDeleteMessage::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogDeleteMessage(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logReadMessage" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogReadMessage::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogReadMessage(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logAddReaction" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogAddReaction::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogAddReaction(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logRemoveReaction" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogRemoveReaction::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogRemoveReaction(
Box::new(inner),
))
}
_ => Ok(ConvoGetLogOutputLogsUnion::Unknown(
crate::api::UnknownUnionVariant {
r#type: type_str.to_string(),
json: None,
cbor: Some(raw.to_vec()),
},
)),
}
}
}
pub async fn convo_get_log(
client: &crate::xrpc::Client,
params: &ConvoGetLogParams,
) -> Result<ConvoGetLogOutput, crate::xrpc::Error> {
client.query("chat.bsky.convo.getLog", params).await
}