shrike 0.1.1

// Code generated by lexgen. DO NOT EDIT.

/// VerificationDefsVerificationView — Verification data for the associated subject.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VerificationDefsVerificationView {
    /// Timestamp when the verification was created.
    pub created_at: crate::syntax::Datetime,
    /// Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying.
    pub display_name: String,
    /// Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying.
    pub handle: crate::syntax::Handle,
    /// The user who issued this verification.
    pub issuer: crate::syntax::Did,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub issuer_profile: Option<VerificationDefsVerificationViewIssuerProfileUnion>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub issuer_repo: Option<VerificationDefsVerificationViewIssuerRepoUnion>,
    /// Describes the reason for revocation, also indicating that the verification is no longer valid.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revoke_reason: Option<String>,
    /// Timestamp when the verification was revoked.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revoked_at: Option<crate::syntax::Datetime>,
    /// The user who revoked this verification.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revoked_by: Option<crate::syntax::Did>,
    /// The subject of the verification.
    pub subject: crate::syntax::Did,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subject_profile: Option<VerificationDefsVerificationViewSubjectProfileUnion>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subject_repo: Option<VerificationDefsVerificationViewSubjectRepoUnion>,
    /// The AT-URI of the verification record.
    pub uri: crate::syntax::AtUri,
    /// Extra fields not defined in the schema (JSON).
    #[serde(flatten)]
    pub extra: std::collections::HashMap<String, serde_json::Value>,
    /// Extra fields not defined in the schema (CBOR).
    #[serde(skip)]
    pub extra_cbor: Vec<(String, Vec<u8>)>,
}

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

impl serde::Serialize for VerificationDefsVerificationViewIssuerProfileUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            VerificationDefsVerificationViewIssuerProfileUnion::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 VerificationDefsVerificationViewIssuerProfileUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            _ => Ok(VerificationDefsVerificationViewIssuerProfileUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl VerificationDefsVerificationViewIssuerProfileUnion {
    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 {
            VerificationDefsVerificationViewIssuerProfileUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

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

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            _ => Ok(VerificationDefsVerificationViewIssuerProfileUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

/// VerificationDefsVerificationViewIssuerRepoUnion is a union type.
#[derive(Debug, Clone)]
pub enum VerificationDefsVerificationViewIssuerRepoUnion {
    ModerationDefsRepoViewDetail(Box<crate::api::tools::ozone::ModerationDefsRepoViewDetail>),
    ModerationDefsRepoViewNotFound(Box<crate::api::tools::ozone::ModerationDefsRepoViewNotFound>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for VerificationDefsVerificationViewIssuerRepoUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            VerificationDefsVerificationViewIssuerRepoUnion::ModerationDefsRepoViewDetail(
                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#repoViewDetail".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            VerificationDefsVerificationViewIssuerRepoUnion::ModerationDefsRepoViewNotFound(
                inner,
            ) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "tools.ozone.moderation.defs#repoViewNotFound".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            VerificationDefsVerificationViewIssuerRepoUnion::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 VerificationDefsVerificationViewIssuerRepoUnion {
    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#repoViewDetail" => {
                let inner: crate::api::tools::ozone::ModerationDefsRepoViewDetail =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    VerificationDefsVerificationViewIssuerRepoUnion::ModerationDefsRepoViewDetail(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#repoViewNotFound" => {
                let inner: crate::api::tools::ozone::ModerationDefsRepoViewNotFound =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    VerificationDefsVerificationViewIssuerRepoUnion::ModerationDefsRepoViewNotFound(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(VerificationDefsVerificationViewIssuerRepoUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl VerificationDefsVerificationViewIssuerRepoUnion {
    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 {
            VerificationDefsVerificationViewIssuerRepoUnion::ModerationDefsRepoViewDetail(
                inner,
            ) => inner.encode_cbor(buf),
            VerificationDefsVerificationViewIssuerRepoUnion::ModerationDefsRepoViewNotFound(
                inner,
            ) => inner.encode_cbor(buf),
            VerificationDefsVerificationViewIssuerRepoUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

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

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "tools.ozone.moderation.defs#repoViewDetail" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner =
                    crate::api::tools::ozone::ModerationDefsRepoViewDetail::decode_cbor(&mut dec)?;
                Ok(
                    VerificationDefsVerificationViewIssuerRepoUnion::ModerationDefsRepoViewDetail(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#repoViewNotFound" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::tools::ozone::ModerationDefsRepoViewNotFound::decode_cbor(
                    &mut dec,
                )?;
                Ok(
                    VerificationDefsVerificationViewIssuerRepoUnion::ModerationDefsRepoViewNotFound(
                        Box::new(inner),
                    ),
                )
            }
            _ => Ok(VerificationDefsVerificationViewIssuerRepoUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

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

impl serde::Serialize for VerificationDefsVerificationViewSubjectProfileUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            VerificationDefsVerificationViewSubjectProfileUnion::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 VerificationDefsVerificationViewSubjectProfileUnion {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let type_str = value
            .get("$type")
            .and_then(|v| v.as_str())
            .unwrap_or_default();
        match type_str {
            _ => Ok(
                VerificationDefsVerificationViewSubjectProfileUnion::Unknown(
                    crate::api::UnknownUnionVariant {
                        r#type: type_str.to_string(),
                        json: Some(value),
                        cbor: None,
                    },
                ),
            ),
        }
    }
}

impl VerificationDefsVerificationViewSubjectProfileUnion {
    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 {
            VerificationDefsVerificationViewSubjectProfileUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

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

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            _ => Ok(
                VerificationDefsVerificationViewSubjectProfileUnion::Unknown(
                    crate::api::UnknownUnionVariant {
                        r#type: type_str.to_string(),
                        json: None,
                        cbor: Some(raw.to_vec()),
                    },
                ),
            ),
        }
    }
}

/// VerificationDefsVerificationViewSubjectRepoUnion is a union type.
#[derive(Debug, Clone)]
pub enum VerificationDefsVerificationViewSubjectRepoUnion {
    ModerationDefsRepoViewDetail(Box<crate::api::tools::ozone::ModerationDefsRepoViewDetail>),
    ModerationDefsRepoViewNotFound(Box<crate::api::tools::ozone::ModerationDefsRepoViewNotFound>),
    Unknown(crate::api::UnknownUnionVariant),
}

impl serde::Serialize for VerificationDefsVerificationViewSubjectRepoUnion {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            VerificationDefsVerificationViewSubjectRepoUnion::ModerationDefsRepoViewDetail(
                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#repoViewDetail".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            VerificationDefsVerificationViewSubjectRepoUnion::ModerationDefsRepoViewNotFound(
                inner,
            ) => {
                let mut map =
                    serde_json::to_value(inner.as_ref()).map_err(serde::ser::Error::custom)?;
                if let serde_json::Value::Object(ref mut m) = map {
                    m.insert(
                        "$type".to_string(),
                        serde_json::Value::String(
                            "tools.ozone.moderation.defs#repoViewNotFound".to_string(),
                        ),
                    );
                }
                map.serialize(serializer)
            }
            VerificationDefsVerificationViewSubjectRepoUnion::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 VerificationDefsVerificationViewSubjectRepoUnion {
    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#repoViewDetail" => {
                let inner: crate::api::tools::ozone::ModerationDefsRepoViewDetail =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(
                    VerificationDefsVerificationViewSubjectRepoUnion::ModerationDefsRepoViewDetail(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#repoViewNotFound" => {
                let inner: crate::api::tools::ozone::ModerationDefsRepoViewNotFound =
                    serde_json::from_value(value).map_err(serde::de::Error::custom)?;
                Ok(VerificationDefsVerificationViewSubjectRepoUnion::ModerationDefsRepoViewNotFound(Box::new(inner)))
            }
            _ => Ok(VerificationDefsVerificationViewSubjectRepoUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: Some(value),
                    cbor: None,
                },
            )),
        }
    }
}

impl VerificationDefsVerificationViewSubjectRepoUnion {
    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 {
            VerificationDefsVerificationViewSubjectRepoUnion::ModerationDefsRepoViewDetail(
                inner,
            ) => inner.encode_cbor(buf),
            VerificationDefsVerificationViewSubjectRepoUnion::ModerationDefsRepoViewNotFound(
                inner,
            ) => inner.encode_cbor(buf),
            VerificationDefsVerificationViewSubjectRepoUnion::Unknown(v) => {
                if let Some(ref data) = v.cbor {
                    buf.extend_from_slice(data);
                    Ok(())
                } else {
                    Err(crate::cbor::CborError::InvalidCbor(
                        "no CBOR data for unknown union variant".into(),
                    ))
                }
            }
        }
    }

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

    pub fn decode_cbor(decoder: &mut crate::cbor::Decoder) -> Result<Self, crate::cbor::CborError> {
        // Save position, decode the value, look for $type key.
        let start = decoder.position();
        let val = decoder.decode()?;
        let end = decoder.position();
        let raw = &decoder.raw_input()[start..end];
        let entries = match val {
            crate::cbor::Value::Map(entries) => entries,
            _ => {
                return Err(crate::cbor::CborError::InvalidCbor(
                    "expected map for union".into(),
                ));
            }
        };
        let type_str = entries
            .iter()
            .find(|(k, _)| *k == "$type")
            .and_then(|(_, v)| match v {
                crate::cbor::Value::Text(s) => Some(*s),
                _ => None,
            })
            .unwrap_or_default();
        match type_str {
            "tools.ozone.moderation.defs#repoViewDetail" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner =
                    crate::api::tools::ozone::ModerationDefsRepoViewDetail::decode_cbor(&mut dec)?;
                Ok(
                    VerificationDefsVerificationViewSubjectRepoUnion::ModerationDefsRepoViewDetail(
                        Box::new(inner),
                    ),
                )
            }
            "tools.ozone.moderation.defs#repoViewNotFound" => {
                let mut dec = crate::cbor::Decoder::new(raw);
                let inner = crate::api::tools::ozone::ModerationDefsRepoViewNotFound::decode_cbor(
                    &mut dec,
                )?;
                Ok(VerificationDefsVerificationViewSubjectRepoUnion::ModerationDefsRepoViewNotFound(Box::new(inner)))
            }
            _ => Ok(VerificationDefsVerificationViewSubjectRepoUnion::Unknown(
                crate::api::UnknownUnionVariant {
                    r#type: type_str.to_string(),
                    json: None,
                    cbor: Some(raw.to_vec()),
                },
            )),
        }
    }
}

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

    pub fn encode_cbor(&self, buf: &mut Vec<u8>) -> Result<(), crate::cbor::CborError> {
        if self.extra_cbor.is_empty() {
            // Fast path: no extra fields to merge.
            let mut count = 6u64;
            if self.revoked_at.is_some() {
                count += 1;
            }
            if self.revoked_by.is_some() {
                count += 1;
            }
            if self.issuer_repo.is_some() {
                count += 1;
            }
            if self.subject_repo.is_some() {
                count += 1;
            }
            if self.revoke_reason.is_some() {
                count += 1;
            }
            if self.issuer_profile.is_some() {
                count += 1;
            }
            if self.subject_profile.is_some() {
                count += 1;
            }
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(count)?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("uri")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.uri.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("handle")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.handle.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("issuer")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.issuer.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("subject")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.subject.as_str())?;
            crate::cbor::Encoder::new(&mut *buf).encode_text("createdAt")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(self.created_at.as_str())?;
            if self.revoked_at.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("revokedAt")?;
                if let Some(ref val) = self.revoked_at {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.revoked_by.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("revokedBy")?;
                if let Some(ref val) = self.revoked_by {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val.as_str())?;
                }
            }
            if self.issuer_repo.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("issuerRepo")?;
                if let Some(ref val) = self.issuer_repo {
                    val.encode_cbor(buf)?;
                }
            }
            crate::cbor::Encoder::new(&mut *buf).encode_text("displayName")?;
            crate::cbor::Encoder::new(&mut *buf).encode_text(&self.display_name)?;
            if self.subject_repo.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("subjectRepo")?;
                if let Some(ref val) = self.subject_repo {
                    val.encode_cbor(buf)?;
                }
            }
            if self.revoke_reason.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("revokeReason")?;
                if let Some(ref val) = self.revoke_reason {
                    crate::cbor::Encoder::new(&mut *buf).encode_text(val)?;
                }
            }
            if self.issuer_profile.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("issuerProfile")?;
                if let Some(ref val) = self.issuer_profile {
                    val.encode_cbor(buf)?;
                }
            }
            if self.subject_profile.is_some() {
                crate::cbor::Encoder::new(&mut *buf).encode_text("subjectProfile")?;
                if let Some(ref val) = self.subject_profile {
                    val.encode_cbor(buf)?;
                }
            }
        } else {
            // Slow path: merge known fields with extra_cbor, sort, encode.
            let mut pairs: Vec<(&str, Vec<u8>)> = Vec::new();
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.uri.as_str())?;
                pairs.push(("uri", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.handle.as_str())?;
                pairs.push(("handle", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.issuer.as_str())?;
                pairs.push(("issuer", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.subject.as_str())?;
                pairs.push(("subject", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(self.created_at.as_str())?;
                pairs.push(("createdAt", vbuf));
            }
            if self.revoked_at.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.revoked_at {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("revokedAt", vbuf));
            }
            if self.revoked_by.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.revoked_by {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val.as_str())?;
                }
                pairs.push(("revokedBy", vbuf));
            }
            if self.issuer_repo.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.issuer_repo {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("issuerRepo", vbuf));
            }
            {
                let mut vbuf = Vec::new();
                crate::cbor::Encoder::new(&mut vbuf).encode_text(&self.display_name)?;
                pairs.push(("displayName", vbuf));
            }
            if self.subject_repo.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.subject_repo {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("subjectRepo", vbuf));
            }
            if self.revoke_reason.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.revoke_reason {
                    crate::cbor::Encoder::new(&mut vbuf).encode_text(val)?;
                }
                pairs.push(("revokeReason", vbuf));
            }
            if self.issuer_profile.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.issuer_profile {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("issuerProfile", vbuf));
            }
            if self.subject_profile.is_some() {
                let mut vbuf = Vec::new();
                if let Some(ref val) = self.subject_profile {
                    val.encode_cbor(&mut vbuf)?;
                }
                pairs.push(("subjectProfile", vbuf));
            }
            for (k, v) in &self.extra_cbor {
                pairs.push((k.as_str(), v.clone()));
            }
            pairs.sort_by(|a, b| crate::cbor::cbor_key_cmp(a.0, b.0));
            crate::cbor::Encoder::new(&mut *buf).encode_map_header(pairs.len() as u64)?;
            for (k, v) in &pairs {
                crate::cbor::Encoder::new(&mut *buf).encode_text(k)?;
                buf.extend_from_slice(v);
            }
        }
        Ok(())
    }

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

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

        let mut field_uri: Option<crate::syntax::AtUri> = None;
        let mut field_handle: Option<crate::syntax::Handle> = None;
        let mut field_issuer: Option<crate::syntax::Did> = None;
        let mut field_subject: Option<crate::syntax::Did> = None;
        let mut field_created_at: Option<crate::syntax::Datetime> = None;
        let mut field_revoked_at: Option<crate::syntax::Datetime> = None;
        let mut field_revoked_by: Option<crate::syntax::Did> = None;
        let mut field_issuer_repo: Option<VerificationDefsVerificationViewIssuerRepoUnion> = None;
        let mut field_display_name: Option<String> = None;
        let mut field_subject_repo: Option<VerificationDefsVerificationViewSubjectRepoUnion> = None;
        let mut field_revoke_reason: Option<String> = None;
        let mut field_issuer_profile: Option<VerificationDefsVerificationViewIssuerProfileUnion> =
            None;
        let mut field_subject_profile: Option<VerificationDefsVerificationViewSubjectProfileUnion> =
            None;
        let mut extra_cbor: Vec<(String, Vec<u8>)> = Vec::new();

        for (key, value) in entries {
            match key {
                "uri" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_uri = Some(
                            crate::syntax::AtUri::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "handle" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_handle = Some(
                            crate::syntax::Handle::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "issuer" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_issuer = 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()));
                    }
                }
                "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()));
                    }
                }
                "createdAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_created_at = Some(
                            crate::syntax::Datetime::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "revokedAt" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_revoked_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()));
                    }
                }
                "revokedBy" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_revoked_by = Some(
                            crate::syntax::Did::try_from(s)
                                .map_err(|e| crate::cbor::CborError::InvalidCbor(e.to_string()))?,
                        );
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "issuerRepo" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_issuer_repo = Some(
                        VerificationDefsVerificationViewIssuerRepoUnion::decode_cbor(&mut dec)?,
                    );
                }
                "displayName" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_display_name = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "subjectRepo" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_subject_repo = Some(
                        VerificationDefsVerificationViewSubjectRepoUnion::decode_cbor(&mut dec)?,
                    );
                }
                "revokeReason" => {
                    if let crate::cbor::Value::Text(s) = value {
                        field_revoke_reason = Some(s.to_string());
                    } else {
                        return Err(crate::cbor::CborError::InvalidCbor("expected text".into()));
                    }
                }
                "issuerProfile" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_issuer_profile = Some(
                        VerificationDefsVerificationViewIssuerProfileUnion::decode_cbor(&mut dec)?,
                    );
                }
                "subjectProfile" => {
                    let raw = crate::cbor::encode_value(&value)?;
                    let mut dec = crate::cbor::Decoder::new(&raw);
                    field_subject_profile = Some(
                        VerificationDefsVerificationViewSubjectProfileUnion::decode_cbor(&mut dec)?,
                    );
                }
                _ => {
                    let raw = crate::cbor::encode_value(&value)?;
                    extra_cbor.push((key.to_string(), raw));
                }
            }
        }

        Ok(VerificationDefsVerificationView {
            uri: field_uri.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'uri'".into())
            })?,
            handle: field_handle.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'handle'".into())
            })?,
            issuer: field_issuer.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'issuer'".into())
            })?,
            subject: field_subject.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'subject'".into())
            })?,
            created_at: field_created_at.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'createdAt'".into())
            })?,
            revoked_at: field_revoked_at,
            revoked_by: field_revoked_by,
            issuer_repo: field_issuer_repo,
            display_name: field_display_name.ok_or_else(|| {
                crate::cbor::CborError::InvalidCbor("missing required field 'displayName'".into())
            })?,
            subject_repo: field_subject_repo,
            revoke_reason: field_revoke_reason,
            issuer_profile: field_issuer_profile,
            subject_profile: field_subject_profile,
            extra: std::collections::HashMap::new(),
            extra_cbor,
        })
    }
}