#[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>),
ConvoDefsLogReadConvo(Box<crate::api::chat::bsky::ConvoDefsLogReadConvo>),
ConvoDefsLogAddMember(Box<crate::api::chat::bsky::ConvoDefsLogAddMember>),
ConvoDefsLogRemoveMember(Box<crate::api::chat::bsky::ConvoDefsLogRemoveMember>),
ConvoDefsLogMemberJoin(Box<crate::api::chat::bsky::ConvoDefsLogMemberJoin>),
ConvoDefsLogMemberLeave(Box<crate::api::chat::bsky::ConvoDefsLogMemberLeave>),
ConvoDefsLogLockConvo(Box<crate::api::chat::bsky::ConvoDefsLogLockConvo>),
ConvoDefsLogUnlockConvo(Box<crate::api::chat::bsky::ConvoDefsLogUnlockConvo>),
ConvoDefsLogLockConvoPermanently(Box<crate::api::chat::bsky::ConvoDefsLogLockConvoPermanently>),
ConvoDefsLogEditGroup(Box<crate::api::chat::bsky::ConvoDefsLogEditGroup>),
ConvoDefsLogCreateJoinLink(Box<crate::api::chat::bsky::ConvoDefsLogCreateJoinLink>),
ConvoDefsLogEditJoinLink(Box<crate::api::chat::bsky::ConvoDefsLogEditJoinLink>),
ConvoDefsLogEnableJoinLink(Box<crate::api::chat::bsky::ConvoDefsLogEnableJoinLink>),
ConvoDefsLogDisableJoinLink(Box<crate::api::chat::bsky::ConvoDefsLogDisableJoinLink>),
ConvoDefsLogIncomingJoinRequest(Box<crate::api::chat::bsky::ConvoDefsLogIncomingJoinRequest>),
ConvoDefsLogApproveJoinRequest(Box<crate::api::chat::bsky::ConvoDefsLogApproveJoinRequest>),
ConvoDefsLogRejectJoinRequest(Box<crate::api::chat::bsky::ConvoDefsLogRejectJoinRequest>),
ConvoDefsLogOutgoingJoinRequest(Box<crate::api::chat::bsky::ConvoDefsLogOutgoingJoinRequest>),
ConvoDefsLogWithdrawIncomingJoinRequest(
Box<crate::api::chat::bsky::ConvoDefsLogWithdrawIncomingJoinRequest>,
),
ConvoDefsLogWithdrawOutgoingJoinRequest(
Box<crate::api::chat::bsky::ConvoDefsLogWithdrawOutgoingJoinRequest>,
),
ConvoDefsLogReadJoinRequests(Box<crate::api::chat::bsky::ConvoDefsLogReadJoinRequests>),
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::ConvoDefsLogReadConvo(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#logReadConvo".to_string()),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogAddMember(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#logAddMember".to_string()),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogRemoveMember(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#logRemoveMember".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogMemberJoin(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#logMemberJoin".to_string()),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogMemberLeave(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#logMemberLeave".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogLockConvo(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#logLockConvo".to_string()),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogUnlockConvo(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#logUnlockConvo".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogLockConvoPermanently(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#logLockConvoPermanently".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogEditGroup(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#logEditGroup".to_string()),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogCreateJoinLink(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#logCreateJoinLink".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogEditJoinLink(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#logEditJoinLink".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogEnableJoinLink(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#logEnableJoinLink".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogDisableJoinLink(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#logDisableJoinLink".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogIncomingJoinRequest(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#logIncomingJoinRequest".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogApproveJoinRequest(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#logApproveJoinRequest".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogRejectJoinRequest(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#logRejectJoinRequest".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogOutgoingJoinRequest(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#logOutgoingJoinRequest".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogWithdrawIncomingJoinRequest(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#logWithdrawIncomingJoinRequest".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogWithdrawOutgoingJoinRequest(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#logWithdrawOutgoingJoinRequest".to_string(),
),
);
}
map.serialize(serializer)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogReadJoinRequests(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#logReadJoinRequests".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),
))
}
"chat.bsky.convo.defs#logReadConvo" => {
let inner: crate::api::chat::bsky::ConvoDefsLogReadConvo =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogReadConvo(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logAddMember" => {
let inner: crate::api::chat::bsky::ConvoDefsLogAddMember =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogAddMember(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logRemoveMember" => {
let inner: crate::api::chat::bsky::ConvoDefsLogRemoveMember =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogRemoveMember(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logMemberJoin" => {
let inner: crate::api::chat::bsky::ConvoDefsLogMemberJoin =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogMemberJoin(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logMemberLeave" => {
let inner: crate::api::chat::bsky::ConvoDefsLogMemberLeave =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogMemberLeave(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logLockConvo" => {
let inner: crate::api::chat::bsky::ConvoDefsLogLockConvo =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogLockConvo(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logUnlockConvo" => {
let inner: crate::api::chat::bsky::ConvoDefsLogUnlockConvo =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogUnlockConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logLockConvoPermanently" => {
let inner: crate::api::chat::bsky::ConvoDefsLogLockConvoPermanently =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogLockConvoPermanently(Box::new(inner)))
}
"chat.bsky.convo.defs#logEditGroup" => {
let inner: crate::api::chat::bsky::ConvoDefsLogEditGroup =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogEditGroup(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logCreateJoinLink" => {
let inner: crate::api::chat::bsky::ConvoDefsLogCreateJoinLink =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogCreateJoinLink(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logEditJoinLink" => {
let inner: crate::api::chat::bsky::ConvoDefsLogEditJoinLink =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogEditJoinLink(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logEnableJoinLink" => {
let inner: crate::api::chat::bsky::ConvoDefsLogEnableJoinLink =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogEnableJoinLink(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logDisableJoinLink" => {
let inner: crate::api::chat::bsky::ConvoDefsLogDisableJoinLink =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogDisableJoinLink(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logIncomingJoinRequest" => {
let inner: crate::api::chat::bsky::ConvoDefsLogIncomingJoinRequest =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogIncomingJoinRequest(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logApproveJoinRequest" => {
let inner: crate::api::chat::bsky::ConvoDefsLogApproveJoinRequest =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogApproveJoinRequest(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logRejectJoinRequest" => {
let inner: crate::api::chat::bsky::ConvoDefsLogRejectJoinRequest =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogRejectJoinRequest(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logOutgoingJoinRequest" => {
let inner: crate::api::chat::bsky::ConvoDefsLogOutgoingJoinRequest =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogOutgoingJoinRequest(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logWithdrawIncomingJoinRequest" => {
let inner: crate::api::chat::bsky::ConvoDefsLogWithdrawIncomingJoinRequest =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ConvoGetLogOutputLogsUnion::ConvoDefsLogWithdrawIncomingJoinRequest(Box::new(
inner,
)),
)
}
"chat.bsky.convo.defs#logWithdrawOutgoingJoinRequest" => {
let inner: crate::api::chat::bsky::ConvoDefsLogWithdrawOutgoingJoinRequest =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(
ConvoGetLogOutputLogsUnion::ConvoDefsLogWithdrawOutgoingJoinRequest(Box::new(
inner,
)),
)
}
"chat.bsky.convo.defs#logReadJoinRequests" => {
let inner: crate::api::chat::bsky::ConvoDefsLogReadJoinRequests =
serde_json::from_value(value).map_err(serde::de::Error::custom)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogReadJoinRequests(
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::ConvoDefsLogReadConvo(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogAddMember(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogRemoveMember(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogMemberJoin(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogMemberLeave(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogLockConvo(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogUnlockConvo(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogLockConvoPermanently(inner) => {
inner.encode_cbor(buf)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogEditGroup(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogCreateJoinLink(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogEditJoinLink(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogEnableJoinLink(inner) => inner.encode_cbor(buf),
ConvoGetLogOutputLogsUnion::ConvoDefsLogDisableJoinLink(inner) => {
inner.encode_cbor(buf)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogIncomingJoinRequest(inner) => {
inner.encode_cbor(buf)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogApproveJoinRequest(inner) => {
inner.encode_cbor(buf)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogRejectJoinRequest(inner) => {
inner.encode_cbor(buf)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogOutgoingJoinRequest(inner) => {
inner.encode_cbor(buf)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogWithdrawIncomingJoinRequest(inner) => {
inner.encode_cbor(buf)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogWithdrawOutgoingJoinRequest(inner) => {
inner.encode_cbor(buf)
}
ConvoGetLogOutputLogsUnion::ConvoDefsLogReadJoinRequests(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),
))
}
"chat.bsky.convo.defs#logReadConvo" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogReadConvo::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogReadConvo(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logAddMember" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogAddMember::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogAddMember(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logRemoveMember" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogRemoveMember::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogRemoveMember(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logMemberJoin" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogMemberJoin::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogMemberJoin(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logMemberLeave" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogMemberLeave::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogMemberLeave(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logLockConvo" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogLockConvo::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogLockConvo(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logUnlockConvo" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogUnlockConvo::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogUnlockConvo(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logLockConvoPermanently" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogLockConvoPermanently::decode_cbor(
&mut dec,
)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogLockConvoPermanently(Box::new(inner)))
}
"chat.bsky.convo.defs#logEditGroup" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner = crate::api::chat::bsky::ConvoDefsLogEditGroup::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogEditGroup(Box::new(
inner,
)))
}
"chat.bsky.convo.defs#logCreateJoinLink" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogCreateJoinLink::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogCreateJoinLink(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logEditJoinLink" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogEditJoinLink::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogEditJoinLink(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logEnableJoinLink" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogEnableJoinLink::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogEnableJoinLink(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logDisableJoinLink" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogDisableJoinLink::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogDisableJoinLink(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logIncomingJoinRequest" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogIncomingJoinRequest::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogIncomingJoinRequest(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logApproveJoinRequest" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogApproveJoinRequest::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogApproveJoinRequest(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logRejectJoinRequest" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogRejectJoinRequest::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogRejectJoinRequest(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logOutgoingJoinRequest" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogOutgoingJoinRequest::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogOutgoingJoinRequest(
Box::new(inner),
))
}
"chat.bsky.convo.defs#logWithdrawIncomingJoinRequest" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogWithdrawIncomingJoinRequest::decode_cbor(
&mut dec,
)?;
Ok(
ConvoGetLogOutputLogsUnion::ConvoDefsLogWithdrawIncomingJoinRequest(Box::new(
inner,
)),
)
}
"chat.bsky.convo.defs#logWithdrawOutgoingJoinRequest" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogWithdrawOutgoingJoinRequest::decode_cbor(
&mut dec,
)?;
Ok(
ConvoGetLogOutputLogsUnion::ConvoDefsLogWithdrawOutgoingJoinRequest(Box::new(
inner,
)),
)
}
"chat.bsky.convo.defs#logReadJoinRequests" => {
let mut dec = crate::cbor::Decoder::new(raw);
let inner =
crate::api::chat::bsky::ConvoDefsLogReadJoinRequests::decode_cbor(&mut dec)?;
Ok(ConvoGetLogOutputLogsUnion::ConvoDefsLogReadJoinRequests(
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
}