trust-tasks-rs 0.32.2

//! Generated by `trust-tasks-codegen` — do not edit by hand.
//!
//! Spec slug: `rooms/revocations/put`. Version: `0.1`.
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
/// Error types.
pub mod error {
    /// Error from a `TryFrom` or `FromStr` implementation.
    pub struct ConversionError(::std::borrow::Cow<'static, str>);
    impl ::std::error::Error for ConversionError {}
    impl ::std::fmt::Display for ConversionError {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
            ::std::fmt::Display::fmt(&self.0, f)
        }
    }
    impl ::std::fmt::Debug for ConversionError {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
            ::std::fmt::Debug::fmt(&self.0, f)
        }
    }
    impl From<&'static str> for ConversionError {
        fn from(value: &'static str) -> Self {
            Self(value.into())
        }
    }
    impl From<String> for ConversionError {
        fn from(value: String) -> Self {
            Self(value.into())
        }
    }
}
/**
What a party presents to act on a room. Carries the whole authority chain: a host MUST NOT dereference an authority credential's `parent` to fetch a link it was not given. Resolving over the network would make verification depend on availability, turn every identifier into a request the host can be induced to make against an address the holder chooses, and signal credential use to whoever hosts the identifier. A host MUST bind the presenter to the chain's leaf. A chain that verifies is evidence that authority was conferred on somebody; it is not evidence that the party presenting it is that somebody. The leaf's subject MUST equal the party the host authenticated for this request — an identity the transport established or a document `proof` proved, never one named in a payload. A host that omits this check authorizes every captured presentation, and the omission is silent, because the chain still verifies.

**Every credential is its issuer's attestation, and only its issuer's.** For the membership credential and for every link of `authority`, a host MUST verify the credential's `proof` with a key that the credential's own `issuer` lists for `assertionMethod` in its DID document, and MUST refuse a credential whose proof names a verification method that is not its issuer's. A proof that verifies under some other party's key is that party's statement, not the issuer's, and confers nothing. The same binding holds for every other document a room signs, such as a `RevocationList`.

**A chain that verifies may still be revoked.** A host that has accepted a `RevocationList` for the room (`rooms/revocations/put`) MUST, from the moment it accepted it, refuse every presentation in which the membership credential or any link of `authority` is revoked by that list, under every task and every version of every task it serves for the room. A chain from which any link is revoked is refused whole: a credential delegated from a revoked one confers nothing, however it was attenuated. The refusal is the same `permissionDenied` as any other failed presentation.*/
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "AuthorityPresentation",
///  "description": "What a party presents to act on a room. Carries the whole authority chain: a host MUST NOT dereference an authority credential's `parent` to fetch a link it was not given. Resolving over the network would make verification depend on availability, turn every identifier into a request the host can be induced to make against an address the holder chooses, and signal credential use to whoever hosts the identifier. A host MUST bind the presenter to the chain's leaf. A chain that verifies is evidence that authority was conferred on somebody; it is not evidence that the party presenting it is that somebody. The leaf's subject MUST equal the party the host authenticated for this request — an identity the transport established or a document `proof` proved, never one named in a payload. A host that omits this check authorizes every captured presentation, and the omission is silent, because the chain still verifies.\n\n**Every credential is its issuer's attestation, and only its issuer's.** For the membership credential and for every link of `authority`, a host MUST verify the credential's `proof` with a key that the credential's own `issuer` lists for `assertionMethod` in its DID document, and MUST refuse a credential whose proof names a verification method that is not its issuer's. A proof that verifies under some other party's key is that party's statement, not the issuer's, and confers nothing. The same binding holds for every other document a room signs, such as a `RevocationList`.\n\n**A chain that verifies may still be revoked.** A host that has accepted a `RevocationList` for the room (`rooms/revocations/put`) MUST, from the moment it accepted it, refuse every presentation in which the membership credential or any link of `authority` is revoked by that list, under every task and every version of every task it serves for the room. A chain from which any link is revoked is refused whole: a credential delegated from a revoked one confers nothing, however it was attenuated. The refusal is the same `permissionDenied` as any other failed presentation.",
///  "type": "object",
///  "required": [
///    "authority",
///    "membership"
///  ],
///  "properties": {
///    "authority": {
///      "description": "The authority chain, LEAF FIRST: the first element is the credential being relied on and the last MUST be one issued by the room itself. Every link the presenter relies on is present, because the host will not fetch one. Capped at 8: verification is linear in chain length and runs on every operation, so an unbounded chain is a denial-of-service surface against the host. The known uses need 2 to 3 — a person attenuating to an agent, and that agent to a sub-agent.",
///      "type": "array",
///      "items": {
///        "type": "string"
///      },
///      "maxItems": 8,
///      "minItems": 1
///    },
///    "membership": {
///      "description": "The presenter's membership credential for this room, or — on a `private` room — a zero-knowledge presentation of it. Serialized per the governing profile.",
///      "type": "string"
///    },
///    "subjectBinding": {
///      "description": "REQUIRED on a `private` room, where the subject identifier is withheld: a proof that the membership credential and the authority chain's leaf describe the SAME subject. Without it two parties pool credentials — one contributes membership, the other authority — and the combination verifies as a single party holding both. A host MUST refuse a private-room presentation that omits this.",
///      "type": "string"
///    }
///  },
///  "additionalProperties": false
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct AuthorityPresentation {
    ///The authority chain, LEAF FIRST: the first element is the credential being relied on and the last MUST be one issued by the room itself. Every link the presenter relies on is present, because the host will not fetch one. Capped at 8: verification is linear in chain length and runs on every operation, so an unbounded chain is a denial-of-service surface against the host. The known uses need 2 to 3 — a person attenuating to an agent, and that agent to a sub-agent.
    pub authority: ::std::vec::Vec<::std::string::String>,
    ///The presenter's membership credential for this room, or — on a `private` room — a zero-knowledge presentation of it. Serialized per the governing profile.
    pub membership: ::std::string::String,
    ///REQUIRED on a `private` room, where the subject identifier is withheld: a proof that the membership credential and the authority chain's leaf describe the SAME subject. Without it two parties pool credentials — one contributes membership, the other authority — and the combination verifies as a single party holding both. A host MUST refuse a private-room presentation that omits this.
    #[serde(
        rename = "subjectBinding",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subject_binding: ::std::option::Option<::std::string::String>,
}
impl AuthorityPresentation {
    pub fn builder() -> builder::AuthorityPresentation {
        Default::default()
    }
}
///Withdraws one credential — a membership credential or any authority link — by its `id`.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "CredentialRevocation",
///  "description": "Withdraws one credential — a membership credential or any authority link — by its `id`.",
///  "type": "object",
///  "required": [
///    "credentialId",
///    "kind",
///    "revokedAt"
///  ],
///  "properties": {
///    "credentialId": {
///      "description": "The `id` of the credential withdrawn, as `rooms/owner/issue-authority` and `rooms/owner/issue-membership` return it, or as an attenuated credential carries it.",
///      "type": "string",
///      "maxLength": 2048,
///      "minLength": 1
///    },
///    "kind": {
///      "const": "credential"
///    },
///    "revokedAt": {
///      "description": "When the room made this withdrawal.",
///      "type": "string",
///      "format": "date-time"
///    },
///    "until": {
///      "description": "OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.",
///      "type": "string",
///      "format": "date-time"
///    }
///  },
///  "additionalProperties": false
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct CredentialRevocation {
    ///The `id` of the credential withdrawn, as `rooms/owner/issue-authority` and `rooms/owner/issue-membership` return it, or as an attenuated credential carries it.
    #[serde(rename = "credentialId")]
    pub credential_id: CredentialRevocationCredentialId,
    pub kind: ::serde_json::Value,
    ///When the room made this withdrawal.
    #[serde(rename = "revokedAt")]
    pub revoked_at: ::chrono::DateTime<::chrono::offset::Utc>,
    ///OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub until: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
}
impl CredentialRevocation {
    pub fn builder() -> builder::CredentialRevocation {
        Default::default()
    }
}
///The `id` of the credential withdrawn, as `rooms/owner/issue-authority` and `rooms/owner/issue-membership` return it, or as an attenuated credential carries it.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "description": "The `id` of the credential withdrawn, as `rooms/owner/issue-authority` and `rooms/owner/issue-membership` return it, or as an attenuated credential carries it.",
///  "type": "string",
///  "maxLength": 2048,
///  "minLength": 1
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CredentialRevocationCredentialId(::std::string::String);
impl ::std::ops::Deref for CredentialRevocationCredentialId {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CredentialRevocationCredentialId> for ::std::string::String {
    fn from(value: CredentialRevocationCredentialId) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CredentialRevocationCredentialId {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2048usize {
            return Err("longer than 2048 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CredentialRevocationCredentialId {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CredentialRevocationCredentialId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CredentialRevocationCredentialId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CredentialRevocationCredentialId {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
/**
A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.

Multihash carries the hash algorithm in-band, so the value is self-describing and the wire format survives an algorithm change without a schema revision; multibase does the same for the base encoding, so a verifier never infers base58 from base64url by context. A bare hex string or a `sha-256:`-style prefix hard-codes one algorithm into the wire contract and is non-conforming here.

This definition constrains the *encoding only*. What the digest is computed over is stated by each referencing field, because it differs legitimately: a digest over a JSON document is taken over its RFC 8785 (JCS) canonicalization, while a digest over an opaque artifact is taken over its bytes. A field whose input is a JSON document and which does not name a canonicalization is not reproducible.

Restricted to the two multibase headers W3C Controlled Identifiers 1.0 §2.4 normatively requires — `z` (base58btc) and `u` (base64url-no-pad). CID permits others but states that "interoperability is not guaranteed between implementations using such values", and a registry whose purpose is interoperability should not mint digests a conforming verifier may be unable to read. The alphabets are enforced rather than assumed: base58btc excludes 0, O, I and l, and an earlier permissive pattern let three published examples carry digests that were not valid base58 at all. base58btc is RECOMMENDED, for consistency with `did:key` and `did:webvh`.*/
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "DigestMultibase",
///  "description": "A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.\n\nMultihash carries the hash algorithm in-band, so the value is self-describing and the wire format survives an algorithm change without a schema revision; multibase does the same for the base encoding, so a verifier never infers base58 from base64url by context. A bare hex string or a `sha-256:`-style prefix hard-codes one algorithm into the wire contract and is non-conforming here.\n\nThis definition constrains the *encoding only*. What the digest is computed over is stated by each referencing field, because it differs legitimately: a digest over a JSON document is taken over its RFC 8785 (JCS) canonicalization, while a digest over an opaque artifact is taken over its bytes. A field whose input is a JSON document and which does not name a canonicalization is not reproducible.\n\nRestricted to the two multibase headers W3C Controlled Identifiers 1.0 §2.4 normatively requires — `z` (base58btc) and `u` (base64url-no-pad). CID permits others but states that \"interoperability is not guaranteed between implementations using such values\", and a registry whose purpose is interoperability should not mint digests a conforming verifier may be unable to read. The alphabets are enforced rather than assumed: base58btc excludes 0, O, I and l, and an earlier permissive pattern let three published examples carry digests that were not valid base58 at all. base58btc is RECOMMENDED, for consistency with `did:key` and `did:webvh`.",
///  "examples": [
///    "zQmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR"
///  ],
///  "type": "string",
///  "minLength": 16,
///  "pattern": "^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DigestMultibase(::std::string::String);
impl ::std::ops::Deref for DigestMultibase {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DigestMultibase> for ::std::string::String {
    fn from(value: DigestMultibase) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DigestMultibase {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() < 16usize {
            return Err("shorter than 16 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err(
                "doesn't match pattern \"^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$\"".into(),
            );
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DigestMultibase {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DigestMultibase {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DigestMultibase {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DigestMultibase {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
///Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Ext",
///  "description": "Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.",
///  "type": "object",
///  "minProperties": 1,
///  "additionalProperties": true,
///  "propertyNames": {
///    "pattern": "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$"
///  }
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(transparent)]
pub struct Ext(pub ::std::collections::HashMap<ExtKey, ::serde_json::Value>);
impl ::std::ops::Deref for Ext {
    type Target = ::std::collections::HashMap<ExtKey, ::serde_json::Value>;
    fn deref(&self) -> &::std::collections::HashMap<ExtKey, ::serde_json::Value> {
        &self.0
    }
}
impl ::std::convert::From<Ext> for ::std::collections::HashMap<ExtKey, ::serde_json::Value> {
    fn from(value: Ext) -> Self {
        value.0
    }
}
impl ::std::convert::From<::std::collections::HashMap<ExtKey, ::serde_json::Value>> for Ext {
    fn from(value: ::std::collections::HashMap<ExtKey, ::serde_json::Value>) -> Self {
        Self(value)
    }
}
///`ExtKey`
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "pattern": "^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ExtKey(::std::string::String);
impl ::std::ops::Deref for ExtKey {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ExtKey> for ::std::string::String {
    fn from(value: ExtKey) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ExtKey {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-z][a-z0-9-]*(\\.[a-z0-9-]+)+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ExtKey {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExtKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExtKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ExtKey {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
///An administrator of a room delivers the room's signed RevocationList to its host, which refuses every withdrawn credential from the moment it accepts the list.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "$id": "https://trusttasks.org/spec/rooms/revocations/put/0.1",
///  "title": "Payload",
///  "description": "An administrator of a room delivers the room's signed RevocationList to its host, which refuses every withdrawn credential from the moment it accepts the list.",
///  "type": "object",
///  "required": [
///    "list",
///    "presentation",
///    "roomId"
///  ],
///  "properties": {
///    "ext": {
///      "description": "Ecosystem-defined extension members per SPEC.md §4.5.1.",
///      "$ref": "#/definitions/Ext"
///    },
///    "list": {
///      "description": "The room's signed, cumulative list. A host accepts it only under the rules of `RevocationList`: the room's own key, a higher sequence, and every live entry of the list it holds still present.",
///      "$ref": "#/definitions/RevocationList"
///    },
///    "presentation": {
///      "description": "Must confer the `admin` action at this room's scope, verified against the list the host already holds — not against the list being delivered. The list's authority is the room's signature on it; the presentation decides only who may make a host process one.",
///      "$ref": "#/definitions/AuthorityPresentation"
///    },
///    "roomId": {
///      "description": "The room. MUST equal `list.roomId`.",
///      "type": "string",
///      "maxLength": 512,
///      "minLength": 1
///    }
///  },
///  "additionalProperties": false
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct Payload {
    ///Ecosystem-defined extension members per SPEC.md §4.5.1.
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub ext: ::std::option::Option<Ext>,
    ///The room's signed, cumulative list. A host accepts it only under the rules of `RevocationList`: the room's own key, a higher sequence, and every live entry of the list it holds still present.
    pub list: RevocationList,
    ///Must confer the `admin` action at this room's scope, verified against the list the host already holds — not against the list being delivered. The list's authority is the room's signature on it; the presentation decides only who may make a host process one.
    pub presentation: AuthorityPresentation,
    ///The room. MUST equal `list.roomId`.
    #[serde(rename = "roomId")]
    pub room_id: PayloadRoomId,
}
impl Payload {
    pub fn builder() -> builder::Payload {
        Default::default()
    }
}
///The room. MUST equal `list.roomId`.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "description": "The room. MUST equal `list.roomId`.",
///  "type": "string",
///  "maxLength": 512,
///  "minLength": 1
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PayloadRoomId(::std::string::String);
impl ::std::ops::Deref for PayloadRoomId {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PayloadRoomId> for ::std::string::String {
    fn from(value: PayloadRoomId) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PayloadRoomId {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 512usize {
            return Err("longer than 512 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PayloadRoomId {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PayloadRoomId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PayloadRoomId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PayloadRoomId {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
///Success response to rooms/revocations/put. Type https://trusttasks.org/spec/rooms/revocations/put/0.1#response. The list the host now holds and enforces, and the moment from which it does.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "Response",
///  "description": "Success response to rooms/revocations/put. Type https://trusttasks.org/spec/rooms/revocations/put/0.1#response. The list the host now holds and enforces, and the moment from which it does.",
///  "type": "object",
///  "required": [
///    "head",
///    "inForceAt",
///    "roomId"
///  ],
///  "properties": {
///    "ext": {
///      "$ref": "#/definitions/Ext"
///    },
///    "head": {
///      "description": "The list the host holds after this request. Equal to the delivered list's head when it was accepted or was a repeat.",
///      "$ref": "#/definitions/RevocationHead"
///    },
///    "inForceAt": {
///      "description": "When the host began refusing what the list withdraws. On a repeat, when it began refusing it the first time.",
///      "type": "string",
///      "format": "date-time"
///    },
///    "roomId": {
///      "type": "string",
///      "maxLength": 512,
///      "minLength": 1
///    }
///  },
///  "additionalProperties": false,
///  "$anchor": "response"
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct Response {
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub ext: ::std::option::Option<Ext>,
    ///The list the host holds after this request. Equal to the delivered list's head when it was accepted or was a repeat.
    pub head: RevocationHead,
    ///When the host began refusing what the list withdraws. On a repeat, when it began refusing it the first time.
    #[serde(rename = "inForceAt")]
    pub in_force_at: ::chrono::DateTime<::chrono::offset::Utc>,
    #[serde(rename = "roomId")]
    pub room_id: ResponseRoomId,
}
impl Response {
    pub fn builder() -> builder::Response {
        Default::default()
    }
}
///`ResponseRoomId`
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "type": "string",
///  "maxLength": 512,
///  "minLength": 1
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ResponseRoomId(::std::string::String);
impl ::std::ops::Deref for ResponseRoomId {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ResponseRoomId> for ::std::string::String {
    fn from(value: ResponseRoomId) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ResponseRoomId {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 512usize {
            return Err("longer than 512 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ResponseRoomId {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ResponseRoomId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ResponseRoomId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ResponseRoomId {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
/**
One withdrawal in a `RevocationList`, discriminated by `kind`.

  - `credential` withdraws one credential, named by its `id`. It matches the membership credential or any authority link whose `id` equals `credentialId`.
  - `subject` withdraws a party: every credential the room's chain gave them **before** `revokedAt`. It matches the membership credential or any authority link whose `credentialSubject` id **or** `issuer` is `subject` and whose `validFrom` is earlier than `revokedAt`. Matching the issuer as well as the subject withdraws what the party delegated before their removal, which no re-admission revives. A credential carrying no `validFrom` is treated as issued before every entry.
  - `room` withdraws every credential whose `validFrom` is earlier than `revokedAt`, whoever holds it. It is how a room resets access — after a compromise, or on a `private` room, where naming a party would disclose who was a member.

**Keyed on time, so a party can come back.** A `subject` or `room` entry withdraws what was issued before it and nothing after, so a room that re-admits a removed party issues fresh credentials and they verify. A `credential` entry is permanent for that one credential, which nobody re-issues.

**Tiers.** On a `private` room a host MUST refuse a list carrying a `credential` or `subject` entry: a presentation there withholds the credential and its subject, so such an entry is one the host cannot apply and a disclosure of who was in the room. Only `room` entries are permitted, and a host serving a `private` room MUST refuse any presentation for which it cannot establish that no credential in it has a `validFrom` earlier than the latest `room` entry's `revokedAt`.*/
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "RevocationEntry",
///  "description": "One withdrawal in a `RevocationList`, discriminated by `kind`.\n\n  - `credential` withdraws one credential, named by its `id`. It matches the membership credential or any authority link whose `id` equals `credentialId`.\n  - `subject` withdraws a party: every credential the room's chain gave them **before** `revokedAt`. It matches the membership credential or any authority link whose `credentialSubject` id **or** `issuer` is `subject` and whose `validFrom` is earlier than `revokedAt`. Matching the issuer as well as the subject withdraws what the party delegated before their removal, which no re-admission revives. A credential carrying no `validFrom` is treated as issued before every entry.\n  - `room` withdraws every credential whose `validFrom` is earlier than `revokedAt`, whoever holds it. It is how a room resets access — after a compromise, or on a `private` room, where naming a party would disclose who was a member.\n\n**Keyed on time, so a party can come back.** A `subject` or `room` entry withdraws what was issued before it and nothing after, so a room that re-admits a removed party issues fresh credentials and they verify. A `credential` entry is permanent for that one credential, which nobody re-issues.\n\n**Tiers.** On a `private` room a host MUST refuse a list carrying a `credential` or `subject` entry: a presentation there withholds the credential and its subject, so such an entry is one the host cannot apply and a disclosure of who was in the room. Only `room` entries are permitted, and a host serving a `private` room MUST refuse any presentation for which it cannot establish that no credential in it has a `validFrom` earlier than the latest `room` entry's `revokedAt`.",
///  "oneOf": [
///    {
///      "$ref": "#/definitions/CredentialRevocation"
///    },
///    {
///      "$ref": "#/definitions/SubjectRevocation"
///    },
///    {
///      "$ref": "#/definitions/RoomRevocation"
///    }
///  ]
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(untagged)]
#[non_exhaustive]
pub enum RevocationEntry {
    CredentialRevocation(CredentialRevocation),
    SubjectRevocation(SubjectRevocation),
    RoomRevocation(RoomRevocation),
}
impl ::std::convert::From<CredentialRevocation> for RevocationEntry {
    fn from(value: CredentialRevocation) -> Self {
        Self::CredentialRevocation(value)
    }
}
impl ::std::convert::From<SubjectRevocation> for RevocationEntry {
    fn from(value: SubjectRevocation) -> Self {
        Self::SubjectRevocation(value)
    }
}
impl ::std::convert::From<RoomRevocation> for RevocationEntry {
    fn from(value: RoomRevocation) -> Self {
        Self::RoomRevocation(value)
    }
}
///Which `RevocationList` a party holds, without its entries: comparable between the room's key holder and a host, and between two hosts, without disclosing whom the room withdrew.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "RevocationHead",
///  "description": "Which `RevocationList` a party holds, without its entries: comparable between the room's key holder and a host, and between two hosts, without disclosing whom the room withdrew.",
///  "type": "object",
///  "required": [
///    "digest",
///    "sequence"
///  ],
///  "properties": {
///    "digest": {
///      "description": "SHA-256 multihash of the list's RFC 8785 (JCS) canonicalization, `proof` included. Two parties holding one sequence with different digests have been given two lists the room signed at one sequence.",
///      "$ref": "#/definitions/DigestMultibase"
///    },
///    "sequence": {
///      "description": "The list's `sequence`.",
///      "type": "integer",
///      "minimum": 1.0
///    }
///  },
///  "additionalProperties": false
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct RevocationHead {
    ///SHA-256 multihash of the list's RFC 8785 (JCS) canonicalization, `proof` included. Two parties holding one sequence with different digests have been given two lists the room signed at one sequence.
    pub digest: DigestMultibase,
    ///The list's `sequence`.
    pub sequence: ::std::num::NonZeroU64,
}
impl RevocationHead {
    pub fn builder() -> builder::RevocationHead {
        Default::default()
    }
}
/**
The room's own statement of which credentials it has withdrawn before they expire — signed by the room, cumulative, and numbered, so that it means the same thing at every host it is delivered to.

**Why the room signs it, and why it is cumulative.** A host authorizes from credentials the room issued and keeps no roster; a withdrawal kept only as a host's own state would make the room unmovable and the host part of the membership. A list the room signed is room state: it moves with the room, any host it is delivered to reaches the same decision, and nothing a host invents can be mistaken for it. It is cumulative — every list carries every entry still in force — so a host holding any one list holds the room's whole withdrawal state, and a host that missed a list loses nothing once it receives a later one.

**Producing.** The room's key holder builds the object without `proof` and signs it with a W3C Data Integrity proof whose `verificationMethod` is a key the room's DID document lists for `assertionMethod` and whose `proofPurpose` is `assertionMethod`. A producer MUST support `eddsa-jcs-2022`. Each list's `sequence` is exactly one greater than the last list the room signed, and the producer MUST NOT sign two different lists at one `sequence`.

**Accepting.** A host MUST refuse a list unless: (1) `roomId` is the room it is delivered for; (2) `proof` verifies with a key of `roomId` listed for `assertionMethod` — a list signed by any other key, however valid the signature, is not the room's; (3) `sequence` is greater than that of the list it holds, or equal with an identical list (a repeat, answered as accepted and changing nothing); (4) it is **append-only** against the list it holds: every entry of the held list appears in it unchanged, unless that entry's `until` has passed. A list that lowers the sequence is a rollback and one that drops a live entry is a reinstatement nobody signed for, and both are refused; two different lists at one `sequence` is the room's key equivocating, and the host keeps the list it holds.

**Applying.** A credential is revoked by an accepted list when any entry matches it (see `RevocationEntry`). An entry whose `until` has passed MAY be discarded by a host and omitted from later lists; no other entry is ever dropped.

**Size.** A list is bounded at 4096 entries. A room that would exceed it uses a `room` entry, which withdraws everything issued before it and lets the room re-issue to those who remain.*/
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "RevocationList",
///  "description": "The room's own statement of which credentials it has withdrawn before they expire — signed by the room, cumulative, and numbered, so that it means the same thing at every host it is delivered to.\n\n**Why the room signs it, and why it is cumulative.** A host authorizes from credentials the room issued and keeps no roster; a withdrawal kept only as a host's own state would make the room unmovable and the host part of the membership. A list the room signed is room state: it moves with the room, any host it is delivered to reaches the same decision, and nothing a host invents can be mistaken for it. It is cumulative — every list carries every entry still in force — so a host holding any one list holds the room's whole withdrawal state, and a host that missed a list loses nothing once it receives a later one.\n\n**Producing.** The room's key holder builds the object without `proof` and signs it with a W3C Data Integrity proof whose `verificationMethod` is a key the room's DID document lists for `assertionMethod` and whose `proofPurpose` is `assertionMethod`. A producer MUST support `eddsa-jcs-2022`. Each list's `sequence` is exactly one greater than the last list the room signed, and the producer MUST NOT sign two different lists at one `sequence`.\n\n**Accepting.** A host MUST refuse a list unless: (1) `roomId` is the room it is delivered for; (2) `proof` verifies with a key of `roomId` listed for `assertionMethod` — a list signed by any other key, however valid the signature, is not the room's; (3) `sequence` is greater than that of the list it holds, or equal with an identical list (a repeat, answered as accepted and changing nothing); (4) it is **append-only** against the list it holds: every entry of the held list appears in it unchanged, unless that entry's `until` has passed. A list that lowers the sequence is a rollback and one that drops a live entry is a reinstatement nobody signed for, and both are refused; two different lists at one `sequence` is the room's key equivocating, and the host keeps the list it holds.\n\n**Applying.** A credential is revoked by an accepted list when any entry matches it (see `RevocationEntry`). An entry whose `until` has passed MAY be discarded by a host and omitted from later lists; no other entry is ever dropped.\n\n**Size.** A list is bounded at 4096 entries. A room that would exceed it uses a `room` entry, which withdraws everything issued before it and lets the room re-issue to those who remain.",
///  "type": "object",
///  "required": [
///    "entries",
///    "issuedAt",
///    "proof",
///    "roomId",
///    "sequence"
///  ],
///  "properties": {
///    "entries": {
///      "description": "Every withdrawal still in force, in the order the room made them. Empty is valid: a room that has revoked nothing, or whose every entry has lapsed, can still state its sequence.",
///      "type": "array",
///      "items": {
///        "$ref": "#/definitions/RevocationEntry"
///      },
///      "maxItems": 4096
///    },
///    "issuedAt": {
///      "description": "When the room signed this list.",
///      "type": "string",
///      "format": "date-time"
///    },
///    "proof": {
///      "description": "The room's Data Integrity proof over every other member, made with a key the room's DID document lists for `assertionMethod`.",
///      "type": "object"
///    },
///    "roomId": {
///      "description": "The room whose credentials this list withdraws, exactly as on the wire. Signed, so a list cannot be replayed against another room.",
///      "type": "string",
///      "maxLength": 512,
///      "minLength": 1
///    },
///    "sequence": {
///      "description": "The list's position in the room's sequence: exactly one greater than the last list the room signed. A host accepts only a list whose sequence is above the one it holds, which is what stops a host, a relayer or an attacker holding an old list from rolling the room's withdrawals back.",
///      "type": "integer",
///      "minimum": 1.0
///    }
///  },
///  "additionalProperties": false
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct RevocationList {
    ///Every withdrawal still in force, in the order the room made them. Empty is valid: a room that has revoked nothing, or whose every entry has lapsed, can still state its sequence.
    pub entries: ::std::vec::Vec<RevocationEntry>,
    ///When the room signed this list.
    #[serde(rename = "issuedAt")]
    pub issued_at: ::chrono::DateTime<::chrono::offset::Utc>,
    ///The room's Data Integrity proof over every other member, made with a key the room's DID document lists for `assertionMethod`.
    pub proof: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    ///The room whose credentials this list withdraws, exactly as on the wire. Signed, so a list cannot be replayed against another room.
    #[serde(rename = "roomId")]
    pub room_id: RevocationListRoomId,
    ///The list's position in the room's sequence: exactly one greater than the last list the room signed. A host accepts only a list whose sequence is above the one it holds, which is what stops a host, a relayer or an attacker holding an old list from rolling the room's withdrawals back.
    pub sequence: ::std::num::NonZeroU64,
}
impl RevocationList {
    pub fn builder() -> builder::RevocationList {
        Default::default()
    }
}
///The room whose credentials this list withdraws, exactly as on the wire. Signed, so a list cannot be replayed against another room.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "description": "The room whose credentials this list withdraws, exactly as on the wire. Signed, so a list cannot be replayed against another room.",
///  "type": "string",
///  "maxLength": 512,
///  "minLength": 1
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RevocationListRoomId(::std::string::String);
impl ::std::ops::Deref for RevocationListRoomId {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RevocationListRoomId> for ::std::string::String {
    fn from(value: RevocationListRoomId) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RevocationListRoomId {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 512usize {
            return Err("longer than 512 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RevocationListRoomId {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RevocationListRoomId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RevocationListRoomId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RevocationListRoomId {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
///Withdraws every credential whose `validFrom` is earlier than `revokedAt`, whoever holds it.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "RoomRevocation",
///  "description": "Withdraws every credential whose `validFrom` is earlier than `revokedAt`, whoever holds it.",
///  "type": "object",
///  "required": [
///    "kind",
///    "revokedAt"
///  ],
///  "properties": {
///    "kind": {
///      "const": "room"
///    },
///    "revokedAt": {
///      "description": "When the room made this withdrawal.",
///      "type": "string",
///      "format": "date-time"
///    },
///    "until": {
///      "description": "OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.",
///      "type": "string",
///      "format": "date-time"
///    }
///  },
///  "additionalProperties": false
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct RoomRevocation {
    pub kind: ::serde_json::Value,
    ///When the room made this withdrawal.
    #[serde(rename = "revokedAt")]
    pub revoked_at: ::chrono::DateTime<::chrono::offset::Utc>,
    ///OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub until: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
}
impl RoomRevocation {
    pub fn builder() -> builder::RoomRevocation {
        Default::default()
    }
}
///Withdraws a party: every credential naming them as subject or issuer whose `validFrom` is earlier than `revokedAt`.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "title": "SubjectRevocation",
///  "description": "Withdraws a party: every credential naming them as subject or issuer whose `validFrom` is earlier than `revokedAt`.",
///  "type": "object",
///  "required": [
///    "kind",
///    "revokedAt",
///    "subject"
///  ],
///  "properties": {
///    "kind": {
///      "const": "subject"
///    },
///    "revokedAt": {
///      "description": "When the room made this withdrawal.",
///      "type": "string",
///      "format": "date-time"
///    },
///    "subject": {
///      "description": "The party withdrawn. Never the room itself.",
///      "type": "string",
///      "maxLength": 2048,
///      "pattern": "^did:"
///    },
///    "until": {
///      "description": "OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.",
///      "type": "string",
///      "format": "date-time"
///    }
///  },
///  "additionalProperties": false
///}
/// ```
/// </details>
#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct SubjectRevocation {
    pub kind: ::serde_json::Value,
    ///When the room made this withdrawal.
    #[serde(rename = "revokedAt")]
    pub revoked_at: ::chrono::DateTime<::chrono::offset::Utc>,
    ///The party withdrawn. Never the room itself.
    pub subject: SubjectRevocationSubject,
    ///OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub until: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
}
impl SubjectRevocation {
    pub fn builder() -> builder::SubjectRevocation {
        Default::default()
    }
}
///The party withdrawn. Never the room itself.
///
/// <details><summary>JSON schema</summary>
///
/// ```json
///{
///  "description": "The party withdrawn. Never the room itself.",
///  "type": "string",
///  "maxLength": 2048,
///  "pattern": "^did:"
///}
/// ```
/// </details>
#[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SubjectRevocationSubject(::std::string::String);
impl ::std::ops::Deref for SubjectRevocationSubject {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SubjectRevocationSubject> for ::std::string::String {
    fn from(value: SubjectRevocationSubject) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SubjectRevocationSubject {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2048usize {
            return Err("longer than 2048 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^did:").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^did:\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SubjectRevocationSubject {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SubjectRevocationSubject {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SubjectRevocationSubject {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SubjectRevocationSubject {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
/// Types for composing complex structures.
pub mod builder {
    #[derive(Clone, Debug)]
    pub struct AuthorityPresentation {
        authority:
            ::std::result::Result<::std::vec::Vec<::std::string::String>, ::std::string::String>,
        membership: ::std::result::Result<::std::string::String, ::std::string::String>,
        subject_binding: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for AuthorityPresentation {
        fn default() -> Self {
            Self {
                authority: Err("no value supplied for authority".to_string()),
                membership: Err("no value supplied for membership".to_string()),
                subject_binding: Ok(Default::default()),
            }
        }
    }
    impl AuthorityPresentation {
        pub fn authority<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.authority = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for authority: {e}"));
            self
        }
        pub fn membership<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.membership = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for membership: {e}"));
            self
        }
        pub fn subject_binding<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.subject_binding = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subject_binding: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AuthorityPresentation> for super::AuthorityPresentation {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AuthorityPresentation,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                authority: value.authority?,
                membership: value.membership?,
                subject_binding: value.subject_binding?,
            })
        }
    }
    impl ::std::convert::From<super::AuthorityPresentation> for AuthorityPresentation {
        fn from(value: super::AuthorityPresentation) -> Self {
            Self {
                authority: Ok(value.authority),
                membership: Ok(value.membership),
                subject_binding: Ok(value.subject_binding),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CredentialRevocation {
        credential_id:
            ::std::result::Result<super::CredentialRevocationCredentialId, ::std::string::String>,
        kind: ::std::result::Result<::serde_json::Value, ::std::string::String>,
        revoked_at:
            ::std::result::Result<::chrono::DateTime<::chrono::offset::Utc>, ::std::string::String>,
        until: ::std::result::Result<
            ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CredentialRevocation {
        fn default() -> Self {
            Self {
                credential_id: Err("no value supplied for credential_id".to_string()),
                kind: Err("no value supplied for kind".to_string()),
                revoked_at: Err("no value supplied for revoked_at".to_string()),
                until: Ok(Default::default()),
            }
        }
    }
    impl CredentialRevocation {
        pub fn credential_id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CredentialRevocationCredentialId>,
            T::Error: ::std::fmt::Display,
        {
            self.credential_id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for credential_id: {e}"));
            self
        }
        pub fn kind<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::serde_json::Value>,
            T::Error: ::std::fmt::Display,
        {
            self.kind = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for kind: {e}"));
            self
        }
        pub fn revoked_at<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::chrono::DateTime<::chrono::offset::Utc>>,
            T::Error: ::std::fmt::Display,
        {
            self.revoked_at = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for revoked_at: {e}"));
            self
        }
        pub fn until<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.until = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for until: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CredentialRevocation> for super::CredentialRevocation {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CredentialRevocation,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                credential_id: value.credential_id?,
                kind: value.kind?,
                revoked_at: value.revoked_at?,
                until: value.until?,
            })
        }
    }
    impl ::std::convert::From<super::CredentialRevocation> for CredentialRevocation {
        fn from(value: super::CredentialRevocation) -> Self {
            Self {
                credential_id: Ok(value.credential_id),
                kind: Ok(value.kind),
                revoked_at: Ok(value.revoked_at),
                until: Ok(value.until),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct Payload {
        ext: ::std::result::Result<::std::option::Option<super::Ext>, ::std::string::String>,
        list: ::std::result::Result<super::RevocationList, ::std::string::String>,
        presentation: ::std::result::Result<super::AuthorityPresentation, ::std::string::String>,
        room_id: ::std::result::Result<super::PayloadRoomId, ::std::string::String>,
    }
    impl ::std::default::Default for Payload {
        fn default() -> Self {
            Self {
                ext: Ok(Default::default()),
                list: Err("no value supplied for list".to_string()),
                presentation: Err("no value supplied for presentation".to_string()),
                room_id: Err("no value supplied for room_id".to_string()),
            }
        }
    }
    impl Payload {
        pub fn ext<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Ext>>,
            T::Error: ::std::fmt::Display,
        {
            self.ext = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ext: {e}"));
            self
        }
        pub fn list<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RevocationList>,
            T::Error: ::std::fmt::Display,
        {
            self.list = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for list: {e}"));
            self
        }
        pub fn presentation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AuthorityPresentation>,
            T::Error: ::std::fmt::Display,
        {
            self.presentation = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for presentation: {e}"));
            self
        }
        pub fn room_id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PayloadRoomId>,
            T::Error: ::std::fmt::Display,
        {
            self.room_id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for room_id: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<Payload> for super::Payload {
        type Error = super::error::ConversionError;
        fn try_from(value: Payload) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                ext: value.ext?,
                list: value.list?,
                presentation: value.presentation?,
                room_id: value.room_id?,
            })
        }
    }
    impl ::std::convert::From<super::Payload> for Payload {
        fn from(value: super::Payload) -> Self {
            Self {
                ext: Ok(value.ext),
                list: Ok(value.list),
                presentation: Ok(value.presentation),
                room_id: Ok(value.room_id),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct Response {
        ext: ::std::result::Result<::std::option::Option<super::Ext>, ::std::string::String>,
        head: ::std::result::Result<super::RevocationHead, ::std::string::String>,
        in_force_at:
            ::std::result::Result<::chrono::DateTime<::chrono::offset::Utc>, ::std::string::String>,
        room_id: ::std::result::Result<super::ResponseRoomId, ::std::string::String>,
    }
    impl ::std::default::Default for Response {
        fn default() -> Self {
            Self {
                ext: Ok(Default::default()),
                head: Err("no value supplied for head".to_string()),
                in_force_at: Err("no value supplied for in_force_at".to_string()),
                room_id: Err("no value supplied for room_id".to_string()),
            }
        }
    }
    impl Response {
        pub fn ext<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Ext>>,
            T::Error: ::std::fmt::Display,
        {
            self.ext = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ext: {e}"));
            self
        }
        pub fn head<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RevocationHead>,
            T::Error: ::std::fmt::Display,
        {
            self.head = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for head: {e}"));
            self
        }
        pub fn in_force_at<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::chrono::DateTime<::chrono::offset::Utc>>,
            T::Error: ::std::fmt::Display,
        {
            self.in_force_at = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for in_force_at: {e}"));
            self
        }
        pub fn room_id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ResponseRoomId>,
            T::Error: ::std::fmt::Display,
        {
            self.room_id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for room_id: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<Response> for super::Response {
        type Error = super::error::ConversionError;
        fn try_from(value: Response) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                ext: value.ext?,
                head: value.head?,
                in_force_at: value.in_force_at?,
                room_id: value.room_id?,
            })
        }
    }
    impl ::std::convert::From<super::Response> for Response {
        fn from(value: super::Response) -> Self {
            Self {
                ext: Ok(value.ext),
                head: Ok(value.head),
                in_force_at: Ok(value.in_force_at),
                room_id: Ok(value.room_id),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct RevocationHead {
        digest: ::std::result::Result<super::DigestMultibase, ::std::string::String>,
        sequence: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for RevocationHead {
        fn default() -> Self {
            Self {
                digest: Err("no value supplied for digest".to_string()),
                sequence: Err("no value supplied for sequence".to_string()),
            }
        }
    }
    impl RevocationHead {
        pub fn digest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DigestMultibase>,
            T::Error: ::std::fmt::Display,
        {
            self.digest = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for digest: {e}"));
            self
        }
        pub fn sequence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.sequence = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sequence: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<RevocationHead> for super::RevocationHead {
        type Error = super::error::ConversionError;
        fn try_from(
            value: RevocationHead,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                digest: value.digest?,
                sequence: value.sequence?,
            })
        }
    }
    impl ::std::convert::From<super::RevocationHead> for RevocationHead {
        fn from(value: super::RevocationHead) -> Self {
            Self {
                digest: Ok(value.digest),
                sequence: Ok(value.sequence),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct RevocationList {
        entries:
            ::std::result::Result<::std::vec::Vec<super::RevocationEntry>, ::std::string::String>,
        issued_at:
            ::std::result::Result<::chrono::DateTime<::chrono::offset::Utc>, ::std::string::String>,
        proof: ::std::result::Result<
            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
            ::std::string::String,
        >,
        room_id: ::std::result::Result<super::RevocationListRoomId, ::std::string::String>,
        sequence: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for RevocationList {
        fn default() -> Self {
            Self {
                entries: Err("no value supplied for entries".to_string()),
                issued_at: Err("no value supplied for issued_at".to_string()),
                proof: Err("no value supplied for proof".to_string()),
                room_id: Err("no value supplied for room_id".to_string()),
                sequence: Err("no value supplied for sequence".to_string()),
            }
        }
    }
    impl RevocationList {
        pub fn entries<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::RevocationEntry>>,
            T::Error: ::std::fmt::Display,
        {
            self.entries = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for entries: {e}"));
            self
        }
        pub fn issued_at<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::chrono::DateTime<::chrono::offset::Utc>>,
            T::Error: ::std::fmt::Display,
        {
            self.issued_at = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for issued_at: {e}"));
            self
        }
        pub fn proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.proof = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proof: {e}"));
            self
        }
        pub fn room_id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RevocationListRoomId>,
            T::Error: ::std::fmt::Display,
        {
            self.room_id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for room_id: {e}"));
            self
        }
        pub fn sequence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.sequence = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sequence: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<RevocationList> for super::RevocationList {
        type Error = super::error::ConversionError;
        fn try_from(
            value: RevocationList,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                entries: value.entries?,
                issued_at: value.issued_at?,
                proof: value.proof?,
                room_id: value.room_id?,
                sequence: value.sequence?,
            })
        }
    }
    impl ::std::convert::From<super::RevocationList> for RevocationList {
        fn from(value: super::RevocationList) -> Self {
            Self {
                entries: Ok(value.entries),
                issued_at: Ok(value.issued_at),
                proof: Ok(value.proof),
                room_id: Ok(value.room_id),
                sequence: Ok(value.sequence),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct RoomRevocation {
        kind: ::std::result::Result<::serde_json::Value, ::std::string::String>,
        revoked_at:
            ::std::result::Result<::chrono::DateTime<::chrono::offset::Utc>, ::std::string::String>,
        until: ::std::result::Result<
            ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for RoomRevocation {
        fn default() -> Self {
            Self {
                kind: Err("no value supplied for kind".to_string()),
                revoked_at: Err("no value supplied for revoked_at".to_string()),
                until: Ok(Default::default()),
            }
        }
    }
    impl RoomRevocation {
        pub fn kind<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::serde_json::Value>,
            T::Error: ::std::fmt::Display,
        {
            self.kind = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for kind: {e}"));
            self
        }
        pub fn revoked_at<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::chrono::DateTime<::chrono::offset::Utc>>,
            T::Error: ::std::fmt::Display,
        {
            self.revoked_at = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for revoked_at: {e}"));
            self
        }
        pub fn until<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.until = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for until: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<RoomRevocation> for super::RoomRevocation {
        type Error = super::error::ConversionError;
        fn try_from(
            value: RoomRevocation,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                kind: value.kind?,
                revoked_at: value.revoked_at?,
                until: value.until?,
            })
        }
    }
    impl ::std::convert::From<super::RoomRevocation> for RoomRevocation {
        fn from(value: super::RoomRevocation) -> Self {
            Self {
                kind: Ok(value.kind),
                revoked_at: Ok(value.revoked_at),
                until: Ok(value.until),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SubjectRevocation {
        kind: ::std::result::Result<::serde_json::Value, ::std::string::String>,
        revoked_at:
            ::std::result::Result<::chrono::DateTime<::chrono::offset::Utc>, ::std::string::String>,
        subject: ::std::result::Result<super::SubjectRevocationSubject, ::std::string::String>,
        until: ::std::result::Result<
            ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SubjectRevocation {
        fn default() -> Self {
            Self {
                kind: Err("no value supplied for kind".to_string()),
                revoked_at: Err("no value supplied for revoked_at".to_string()),
                subject: Err("no value supplied for subject".to_string()),
                until: Ok(Default::default()),
            }
        }
    }
    impl SubjectRevocation {
        pub fn kind<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::serde_json::Value>,
            T::Error: ::std::fmt::Display,
        {
            self.kind = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for kind: {e}"));
            self
        }
        pub fn revoked_at<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::chrono::DateTime<::chrono::offset::Utc>>,
            T::Error: ::std::fmt::Display,
        {
            self.revoked_at = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for revoked_at: {e}"));
            self
        }
        pub fn subject<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SubjectRevocationSubject>,
            T::Error: ::std::fmt::Display,
        {
            self.subject = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subject: {e}"));
            self
        }
        pub fn until<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.until = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for until: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SubjectRevocation> for super::SubjectRevocation {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SubjectRevocation,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                kind: value.kind?,
                revoked_at: value.revoked_at?,
                subject: value.subject?,
                until: value.until?,
            })
        }
    }
    impl ::std::convert::From<super::SubjectRevocation> for SubjectRevocation {
        fn from(value: super::SubjectRevocation) -> Self {
            Self {
                kind: Ok(value.kind),
                revoked_at: Ok(value.revoked_at),
                subject: Ok(value.subject),
                until: Ok(value.until),
            }
        }
    }
}
impl crate::Payload for Payload {
    const TYPE_URI: &'static str = "https://trusttasks.org/spec/rooms/revocations/put/0.1";
    const IS_PROOF_REQUIRED: bool = true;
    const IS_ISSUED_AT_REQUIRED: bool = true;
    const IS_RECIPIENT_REQUIRED: bool = true;
    const PAYLOAD_SCHEMA: Option<&'static str> = Some(
        "{\n  \"$defs\": {\n    \"AuthorityPresentation\": {\n      \"additionalProperties\": false,\n      \"description\": \"What a party presents to act on a room. Carries the whole authority chain: a host MUST NOT dereference an authority credential's `parent` to fetch a link it was not given. Resolving over the network would make verification depend on availability, turn every identifier into a request the host can be induced to make against an address the holder chooses, and signal credential use to whoever hosts the identifier. A host MUST bind the presenter to the chain's leaf. A chain that verifies is evidence that authority was conferred on somebody; it is not evidence that the party presenting it is that somebody. The leaf's subject MUST equal the party the host authenticated for this request — an identity the transport established or a document `proof` proved, never one named in a payload. A host that omits this check authorizes every captured presentation, and the omission is silent, because the chain still verifies.\\n\\n**Every credential is its issuer's attestation, and only its issuer's.** For the membership credential and for every link of `authority`, a host MUST verify the credential's `proof` with a key that the credential's own `issuer` lists for `assertionMethod` in its DID document, and MUST refuse a credential whose proof names a verification method that is not its issuer's. A proof that verifies under some other party's key is that party's statement, not the issuer's, and confers nothing. The same binding holds for every other document a room signs, such as a `RevocationList`.\\n\\n**A chain that verifies may still be revoked.** A host that has accepted a `RevocationList` for the room (`rooms/revocations/put`) MUST, from the moment it accepted it, refuse every presentation in which the membership credential or any link of `authority` is revoked by that list, under every task and every version of every task it serves for the room. A chain from which any link is revoked is refused whole: a credential delegated from a revoked one confers nothing, however it was attenuated. The refusal is the same `permissionDenied` as any other failed presentation.\",\n      \"properties\": {\n        \"authority\": {\n          \"description\": \"The authority chain, LEAF FIRST: the first element is the credential being relied on and the last MUST be one issued by the room itself. Every link the presenter relies on is present, because the host will not fetch one. Capped at 8: verification is linear in chain length and runs on every operation, so an unbounded chain is a denial-of-service surface against the host. The known uses need 2 to 3 — a person attenuating to an agent, and that agent to a sub-agent.\",\n          \"items\": {\n            \"type\": \"string\"\n          },\n          \"maxItems\": 8,\n          \"minItems\": 1,\n          \"type\": \"array\"\n        },\n        \"membership\": {\n          \"description\": \"The presenter's membership credential for this room, or — on a `private` room — a zero-knowledge presentation of it. Serialized per the governing profile.\",\n          \"type\": \"string\"\n        },\n        \"subjectBinding\": {\n          \"description\": \"REQUIRED on a `private` room, where the subject identifier is withheld: a proof that the membership credential and the authority chain's leaf describe the SAME subject. Without it two parties pool credentials — one contributes membership, the other authority — and the combination verifies as a single party holding both. A host MUST refuse a private-room presentation that omits this.\",\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"membership\",\n        \"authority\"\n      ],\n      \"title\": \"AuthorityPresentation\",\n      \"type\": \"object\"\n    },\n    \"CredentialRevocation\": {\n      \"additionalProperties\": false,\n      \"description\": \"Withdraws one credential — a membership credential or any authority link — by its `id`.\",\n      \"properties\": {\n        \"credentialId\": {\n          \"description\": \"The `id` of the credential withdrawn, as `rooms/owner/issue-authority` and `rooms/owner/issue-membership` return it, or as an attenuated credential carries it.\",\n          \"maxLength\": 2048,\n          \"minLength\": 1,\n          \"type\": \"string\"\n        },\n        \"kind\": {\n          \"const\": \"credential\"\n        },\n        \"revokedAt\": {\n          \"description\": \"When the room made this withdrawal.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"until\": {\n          \"description\": \"OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"kind\",\n        \"credentialId\",\n        \"revokedAt\"\n      ],\n      \"title\": \"CredentialRevocation\",\n      \"type\": \"object\"\n    },\n    \"DigestMultibase\": {\n      \"description\": \"A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.\\n\\nMultihash carries the hash algorithm in-band, so the value is self-describing and the wire format survives an algorithm change without a schema revision; multibase does the same for the base encoding, so a verifier never infers base58 from base64url by context. A bare hex string or a `sha-256:`-style prefix hard-codes one algorithm into the wire contract and is non-conforming here.\\n\\nThis definition constrains the *encoding only*. What the digest is computed over is stated by each referencing field, because it differs legitimately: a digest over a JSON document is taken over its RFC 8785 (JCS) canonicalization, while a digest over an opaque artifact is taken over its bytes. A field whose input is a JSON document and which does not name a canonicalization is not reproducible.\\n\\nRestricted to the two multibase headers W3C Controlled Identifiers 1.0 §2.4 normatively requires — `z` (base58btc) and `u` (base64url-no-pad). CID permits others but states that \\\"interoperability is not guaranteed between implementations using such values\\\", and a registry whose purpose is interoperability should not mint digests a conforming verifier may be unable to read. The alphabets are enforced rather than assumed: base58btc excludes 0, O, I and l, and an earlier permissive pattern let three published examples carry digests that were not valid base58 at all. base58btc is RECOMMENDED, for consistency with `did:key` and `did:webvh`.\",\n      \"examples\": [\n        \"zQmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR\"\n      ],\n      \"minLength\": 16,\n      \"pattern\": \"^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$\",\n      \"title\": \"DigestMultibase\",\n      \"type\": \"string\"\n    },\n    \"Ext\": {\n      \"additionalProperties\": true,\n      \"description\": \"Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.\",\n      \"minProperties\": 1,\n      \"propertyNames\": {\n        \"pattern\": \"^[a-z][a-z0-9-]*(\\\\.[a-z0-9-]+)+$\"\n      },\n      \"title\": \"Ext\",\n      \"type\": \"object\"\n    },\n    \"Response\": {\n      \"$anchor\": \"response\",\n      \"additionalProperties\": false,\n      \"description\": \"Success response to rooms/revocations/put. Type https://trusttasks.org/spec/rooms/revocations/put/0.1#response. The list the host now holds and enforces, and the moment from which it does.\",\n      \"properties\": {\n        \"ext\": {\n          \"$ref\": \"#/$defs/Ext\"\n        },\n        \"head\": {\n          \"$ref\": \"#/$defs/RevocationHead\",\n          \"description\": \"The list the host holds after this request. Equal to the delivered list's head when it was accepted or was a repeat.\"\n        },\n        \"inForceAt\": {\n          \"description\": \"When the host began refusing what the list withdraws. On a repeat, when it began refusing it the first time.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"roomId\": {\n          \"maxLength\": 512,\n          \"minLength\": 1,\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"roomId\",\n        \"head\",\n        \"inForceAt\"\n      ],\n      \"title\": \"Rooms Revocations Put — response payload\",\n      \"type\": \"object\"\n    },\n    \"RevocationEntry\": {\n      \"description\": \"One withdrawal in a `RevocationList`, discriminated by `kind`.\\n\\n  - `credential` withdraws one credential, named by its `id`. It matches the membership credential or any authority link whose `id` equals `credentialId`.\\n  - `subject` withdraws a party: every credential the room's chain gave them **before** `revokedAt`. It matches the membership credential or any authority link whose `credentialSubject` id **or** `issuer` is `subject` and whose `validFrom` is earlier than `revokedAt`. Matching the issuer as well as the subject withdraws what the party delegated before their removal, which no re-admission revives. A credential carrying no `validFrom` is treated as issued before every entry.\\n  - `room` withdraws every credential whose `validFrom` is earlier than `revokedAt`, whoever holds it. It is how a room resets access — after a compromise, or on a `private` room, where naming a party would disclose who was a member.\\n\\n**Keyed on time, so a party can come back.** A `subject` or `room` entry withdraws what was issued before it and nothing after, so a room that re-admits a removed party issues fresh credentials and they verify. A `credential` entry is permanent for that one credential, which nobody re-issues.\\n\\n**Tiers.** On a `private` room a host MUST refuse a list carrying a `credential` or `subject` entry: a presentation there withholds the credential and its subject, so such an entry is one the host cannot apply and a disclosure of who was in the room. Only `room` entries are permitted, and a host serving a `private` room MUST refuse any presentation for which it cannot establish that no credential in it has a `validFrom` earlier than the latest `room` entry's `revokedAt`.\",\n      \"oneOf\": [\n        {\n          \"$ref\": \"#/$defs/CredentialRevocation\"\n        },\n        {\n          \"$ref\": \"#/$defs/SubjectRevocation\"\n        },\n        {\n          \"$ref\": \"#/$defs/RoomRevocation\"\n        }\n      ],\n      \"title\": \"RevocationEntry\"\n    },\n    \"RevocationHead\": {\n      \"additionalProperties\": false,\n      \"description\": \"Which `RevocationList` a party holds, without its entries: comparable between the room's key holder and a host, and between two hosts, without disclosing whom the room withdrew.\",\n      \"properties\": {\n        \"digest\": {\n          \"$ref\": \"#/$defs/DigestMultibase\",\n          \"description\": \"SHA-256 multihash of the list's RFC 8785 (JCS) canonicalization, `proof` included. Two parties holding one sequence with different digests have been given two lists the room signed at one sequence.\"\n        },\n        \"sequence\": {\n          \"description\": \"The list's `sequence`.\",\n          \"minimum\": 1,\n          \"type\": \"integer\"\n        }\n      },\n      \"required\": [\n        \"sequence\",\n        \"digest\"\n      ],\n      \"title\": \"RevocationHead\",\n      \"type\": \"object\"\n    },\n    \"RevocationList\": {\n      \"additionalProperties\": false,\n      \"description\": \"The room's own statement of which credentials it has withdrawn before they expire — signed by the room, cumulative, and numbered, so that it means the same thing at every host it is delivered to.\\n\\n**Why the room signs it, and why it is cumulative.** A host authorizes from credentials the room issued and keeps no roster; a withdrawal kept only as a host's own state would make the room unmovable and the host part of the membership. A list the room signed is room state: it moves with the room, any host it is delivered to reaches the same decision, and nothing a host invents can be mistaken for it. It is cumulative — every list carries every entry still in force — so a host holding any one list holds the room's whole withdrawal state, and a host that missed a list loses nothing once it receives a later one.\\n\\n**Producing.** The room's key holder builds the object without `proof` and signs it with a W3C Data Integrity proof whose `verificationMethod` is a key the room's DID document lists for `assertionMethod` and whose `proofPurpose` is `assertionMethod`. A producer MUST support `eddsa-jcs-2022`. Each list's `sequence` is exactly one greater than the last list the room signed, and the producer MUST NOT sign two different lists at one `sequence`.\\n\\n**Accepting.** A host MUST refuse a list unless: (1) `roomId` is the room it is delivered for; (2) `proof` verifies with a key of `roomId` listed for `assertionMethod` — a list signed by any other key, however valid the signature, is not the room's; (3) `sequence` is greater than that of the list it holds, or equal with an identical list (a repeat, answered as accepted and changing nothing); (4) it is **append-only** against the list it holds: every entry of the held list appears in it unchanged, unless that entry's `until` has passed. A list that lowers the sequence is a rollback and one that drops a live entry is a reinstatement nobody signed for, and both are refused; two different lists at one `sequence` is the room's key equivocating, and the host keeps the list it holds.\\n\\n**Applying.** A credential is revoked by an accepted list when any entry matches it (see `RevocationEntry`). An entry whose `until` has passed MAY be discarded by a host and omitted from later lists; no other entry is ever dropped.\\n\\n**Size.** A list is bounded at 4096 entries. A room that would exceed it uses a `room` entry, which withdraws everything issued before it and lets the room re-issue to those who remain.\",\n      \"properties\": {\n        \"entries\": {\n          \"description\": \"Every withdrawal still in force, in the order the room made them. Empty is valid: a room that has revoked nothing, or whose every entry has lapsed, can still state its sequence.\",\n          \"items\": {\n            \"$ref\": \"#/$defs/RevocationEntry\"\n          },\n          \"maxItems\": 4096,\n          \"type\": \"array\"\n        },\n        \"issuedAt\": {\n          \"description\": \"When the room signed this list.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"proof\": {\n          \"description\": \"The room's Data Integrity proof over every other member, made with a key the room's DID document lists for `assertionMethod`.\",\n          \"type\": \"object\"\n        },\n        \"roomId\": {\n          \"description\": \"The room whose credentials this list withdraws, exactly as on the wire. Signed, so a list cannot be replayed against another room.\",\n          \"maxLength\": 512,\n          \"minLength\": 1,\n          \"type\": \"string\"\n        },\n        \"sequence\": {\n          \"description\": \"The list's position in the room's sequence: exactly one greater than the last list the room signed. A host accepts only a list whose sequence is above the one it holds, which is what stops a host, a relayer or an attacker holding an old list from rolling the room's withdrawals back.\",\n          \"minimum\": 1,\n          \"type\": \"integer\"\n        }\n      },\n      \"required\": [\n        \"roomId\",\n        \"sequence\",\n        \"issuedAt\",\n        \"entries\",\n        \"proof\"\n      ],\n      \"title\": \"RevocationList\",\n      \"type\": \"object\"\n    },\n    \"RoomRevocation\": {\n      \"additionalProperties\": false,\n      \"description\": \"Withdraws every credential whose `validFrom` is earlier than `revokedAt`, whoever holds it.\",\n      \"properties\": {\n        \"kind\": {\n          \"const\": \"room\"\n        },\n        \"revokedAt\": {\n          \"description\": \"When the room made this withdrawal.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"until\": {\n          \"description\": \"OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"kind\",\n        \"revokedAt\"\n      ],\n      \"title\": \"RoomRevocation\",\n      \"type\": \"object\"\n    },\n    \"SubjectRevocation\": {\n      \"additionalProperties\": false,\n      \"description\": \"Withdraws a party: every credential naming them as subject or issuer whose `validFrom` is earlier than `revokedAt`.\",\n      \"properties\": {\n        \"kind\": {\n          \"const\": \"subject\"\n        },\n        \"revokedAt\": {\n          \"description\": \"When the room made this withdrawal.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"subject\": {\n          \"description\": \"The party withdrawn. Never the room itself.\",\n          \"maxLength\": 2048,\n          \"pattern\": \"^did:\",\n          \"type\": \"string\"\n        },\n        \"until\": {\n          \"description\": \"OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"kind\",\n        \"subject\",\n        \"revokedAt\"\n      ],\n      \"title\": \"SubjectRevocation\",\n      \"type\": \"object\"\n    }\n  },\n  \"$id\": \"https://trusttasks.org/spec/rooms/revocations/put/0.1\",\n  \"$schema\": \"https://json-schema.org/draft/2020-12/schema\",\n  \"additionalProperties\": false,\n  \"description\": \"An administrator of a room delivers the room's signed RevocationList to its host, which refuses every withdrawn credential from the moment it accepts the list.\",\n  \"properties\": {\n    \"ext\": {\n      \"$ref\": \"#/$defs/Ext\",\n      \"description\": \"Ecosystem-defined extension members per SPEC.md §4.5.1.\"\n    },\n    \"list\": {\n      \"$ref\": \"#/$defs/RevocationList\",\n      \"description\": \"The room's signed, cumulative list. A host accepts it only under the rules of `RevocationList`: the room's own key, a higher sequence, and every live entry of the list it holds still present.\"\n    },\n    \"presentation\": {\n      \"$ref\": \"#/$defs/AuthorityPresentation\",\n      \"description\": \"Must confer the `admin` action at this room's scope, verified against the list the host already holds — not against the list being delivered. The list's authority is the room's signature on it; the presentation decides only who may make a host process one.\"\n    },\n    \"roomId\": {\n      \"description\": \"The room. MUST equal `list.roomId`.\",\n      \"maxLength\": 512,\n      \"minLength\": 1,\n      \"type\": \"string\"\n    }\n  },\n  \"required\": [\n    \"roomId\",\n    \"presentation\",\n    \"list\"\n  ],\n  \"title\": \"Rooms Revocations Put — payload\",\n  \"type\": \"object\"\n}\n",
    );
}
impl crate::Payload for Response {
    const TYPE_URI: &'static str = "https://trusttasks.org/spec/rooms/revocations/put/0.1#response";
    const IS_PROOF_REQUIRED: bool = true;
    const IS_ISSUED_AT_REQUIRED: bool = true;
    const IS_RECIPIENT_REQUIRED: bool = true;
    const PAYLOAD_SCHEMA: Option<&'static str> = Some(
        "{\n  \"$defs\": {\n    \"AuthorityPresentation\": {\n      \"additionalProperties\": false,\n      \"description\": \"What a party presents to act on a room. Carries the whole authority chain: a host MUST NOT dereference an authority credential's `parent` to fetch a link it was not given. Resolving over the network would make verification depend on availability, turn every identifier into a request the host can be induced to make against an address the holder chooses, and signal credential use to whoever hosts the identifier. A host MUST bind the presenter to the chain's leaf. A chain that verifies is evidence that authority was conferred on somebody; it is not evidence that the party presenting it is that somebody. The leaf's subject MUST equal the party the host authenticated for this request — an identity the transport established or a document `proof` proved, never one named in a payload. A host that omits this check authorizes every captured presentation, and the omission is silent, because the chain still verifies.\\n\\n**Every credential is its issuer's attestation, and only its issuer's.** For the membership credential and for every link of `authority`, a host MUST verify the credential's `proof` with a key that the credential's own `issuer` lists for `assertionMethod` in its DID document, and MUST refuse a credential whose proof names a verification method that is not its issuer's. A proof that verifies under some other party's key is that party's statement, not the issuer's, and confers nothing. The same binding holds for every other document a room signs, such as a `RevocationList`.\\n\\n**A chain that verifies may still be revoked.** A host that has accepted a `RevocationList` for the room (`rooms/revocations/put`) MUST, from the moment it accepted it, refuse every presentation in which the membership credential or any link of `authority` is revoked by that list, under every task and every version of every task it serves for the room. A chain from which any link is revoked is refused whole: a credential delegated from a revoked one confers nothing, however it was attenuated. The refusal is the same `permissionDenied` as any other failed presentation.\",\n      \"properties\": {\n        \"authority\": {\n          \"description\": \"The authority chain, LEAF FIRST: the first element is the credential being relied on and the last MUST be one issued by the room itself. Every link the presenter relies on is present, because the host will not fetch one. Capped at 8: verification is linear in chain length and runs on every operation, so an unbounded chain is a denial-of-service surface against the host. The known uses need 2 to 3 — a person attenuating to an agent, and that agent to a sub-agent.\",\n          \"items\": {\n            \"type\": \"string\"\n          },\n          \"maxItems\": 8,\n          \"minItems\": 1,\n          \"type\": \"array\"\n        },\n        \"membership\": {\n          \"description\": \"The presenter's membership credential for this room, or — on a `private` room — a zero-knowledge presentation of it. Serialized per the governing profile.\",\n          \"type\": \"string\"\n        },\n        \"subjectBinding\": {\n          \"description\": \"REQUIRED on a `private` room, where the subject identifier is withheld: a proof that the membership credential and the authority chain's leaf describe the SAME subject. Without it two parties pool credentials — one contributes membership, the other authority — and the combination verifies as a single party holding both. A host MUST refuse a private-room presentation that omits this.\",\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"membership\",\n        \"authority\"\n      ],\n      \"title\": \"AuthorityPresentation\",\n      \"type\": \"object\"\n    },\n    \"CredentialRevocation\": {\n      \"additionalProperties\": false,\n      \"description\": \"Withdraws one credential — a membership credential or any authority link — by its `id`.\",\n      \"properties\": {\n        \"credentialId\": {\n          \"description\": \"The `id` of the credential withdrawn, as `rooms/owner/issue-authority` and `rooms/owner/issue-membership` return it, or as an attenuated credential carries it.\",\n          \"maxLength\": 2048,\n          \"minLength\": 1,\n          \"type\": \"string\"\n        },\n        \"kind\": {\n          \"const\": \"credential\"\n        },\n        \"revokedAt\": {\n          \"description\": \"When the room made this withdrawal.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"until\": {\n          \"description\": \"OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"kind\",\n        \"credentialId\",\n        \"revokedAt\"\n      ],\n      \"title\": \"CredentialRevocation\",\n      \"type\": \"object\"\n    },\n    \"DigestMultibase\": {\n      \"description\": \"A cryptographic digest as a multibase-encoded multihash — the encoding the W3C Verifiable Credentials Data Model 2.0 defines for `digestMultibase`, and the one `did:webvh` uses for its SCID and entry hashes.\\n\\nMultihash carries the hash algorithm in-band, so the value is self-describing and the wire format survives an algorithm change without a schema revision; multibase does the same for the base encoding, so a verifier never infers base58 from base64url by context. A bare hex string or a `sha-256:`-style prefix hard-codes one algorithm into the wire contract and is non-conforming here.\\n\\nThis definition constrains the *encoding only*. What the digest is computed over is stated by each referencing field, because it differs legitimately: a digest over a JSON document is taken over its RFC 8785 (JCS) canonicalization, while a digest over an opaque artifact is taken over its bytes. A field whose input is a JSON document and which does not name a canonicalization is not reproducible.\\n\\nRestricted to the two multibase headers W3C Controlled Identifiers 1.0 §2.4 normatively requires — `z` (base58btc) and `u` (base64url-no-pad). CID permits others but states that \\\"interoperability is not guaranteed between implementations using such values\\\", and a registry whose purpose is interoperability should not mint digests a conforming verifier may be unable to read. The alphabets are enforced rather than assumed: base58btc excludes 0, O, I and l, and an earlier permissive pattern let three published examples carry digests that were not valid base58 at all. base58btc is RECOMMENDED, for consistency with `did:key` and `did:webvh`.\",\n      \"examples\": [\n        \"zQmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR\"\n      ],\n      \"minLength\": 16,\n      \"pattern\": \"^(z[1-9A-HJ-NP-Za-km-z]+|u[A-Za-z0-9_-]+)$\",\n      \"title\": \"DigestMultibase\",\n      \"type\": \"string\"\n    },\n    \"Ext\": {\n      \"additionalProperties\": true,\n      \"description\": \"Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.\",\n      \"minProperties\": 1,\n      \"propertyNames\": {\n        \"pattern\": \"^[a-z][a-z0-9-]*(\\\\.[a-z0-9-]+)+$\"\n      },\n      \"title\": \"Ext\",\n      \"type\": \"object\"\n    },\n    \"Response\": {\n      \"$anchor\": \"response\",\n      \"additionalProperties\": false,\n      \"description\": \"Success response to rooms/revocations/put. Type https://trusttasks.org/spec/rooms/revocations/put/0.1#response. The list the host now holds and enforces, and the moment from which it does.\",\n      \"properties\": {\n        \"ext\": {\n          \"$ref\": \"#/$defs/Ext\"\n        },\n        \"head\": {\n          \"$ref\": \"#/$defs/RevocationHead\",\n          \"description\": \"The list the host holds after this request. Equal to the delivered list's head when it was accepted or was a repeat.\"\n        },\n        \"inForceAt\": {\n          \"description\": \"When the host began refusing what the list withdraws. On a repeat, when it began refusing it the first time.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"roomId\": {\n          \"maxLength\": 512,\n          \"minLength\": 1,\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"roomId\",\n        \"head\",\n        \"inForceAt\"\n      ],\n      \"title\": \"Rooms Revocations Put — response payload\",\n      \"type\": \"object\"\n    },\n    \"RevocationEntry\": {\n      \"description\": \"One withdrawal in a `RevocationList`, discriminated by `kind`.\\n\\n  - `credential` withdraws one credential, named by its `id`. It matches the membership credential or any authority link whose `id` equals `credentialId`.\\n  - `subject` withdraws a party: every credential the room's chain gave them **before** `revokedAt`. It matches the membership credential or any authority link whose `credentialSubject` id **or** `issuer` is `subject` and whose `validFrom` is earlier than `revokedAt`. Matching the issuer as well as the subject withdraws what the party delegated before their removal, which no re-admission revives. A credential carrying no `validFrom` is treated as issued before every entry.\\n  - `room` withdraws every credential whose `validFrom` is earlier than `revokedAt`, whoever holds it. It is how a room resets access — after a compromise, or on a `private` room, where naming a party would disclose who was a member.\\n\\n**Keyed on time, so a party can come back.** A `subject` or `room` entry withdraws what was issued before it and nothing after, so a room that re-admits a removed party issues fresh credentials and they verify. A `credential` entry is permanent for that one credential, which nobody re-issues.\\n\\n**Tiers.** On a `private` room a host MUST refuse a list carrying a `credential` or `subject` entry: a presentation there withholds the credential and its subject, so such an entry is one the host cannot apply and a disclosure of who was in the room. Only `room` entries are permitted, and a host serving a `private` room MUST refuse any presentation for which it cannot establish that no credential in it has a `validFrom` earlier than the latest `room` entry's `revokedAt`.\",\n      \"oneOf\": [\n        {\n          \"$ref\": \"#/$defs/CredentialRevocation\"\n        },\n        {\n          \"$ref\": \"#/$defs/SubjectRevocation\"\n        },\n        {\n          \"$ref\": \"#/$defs/RoomRevocation\"\n        }\n      ],\n      \"title\": \"RevocationEntry\"\n    },\n    \"RevocationHead\": {\n      \"additionalProperties\": false,\n      \"description\": \"Which `RevocationList` a party holds, without its entries: comparable between the room's key holder and a host, and between two hosts, without disclosing whom the room withdrew.\",\n      \"properties\": {\n        \"digest\": {\n          \"$ref\": \"#/$defs/DigestMultibase\",\n          \"description\": \"SHA-256 multihash of the list's RFC 8785 (JCS) canonicalization, `proof` included. Two parties holding one sequence with different digests have been given two lists the room signed at one sequence.\"\n        },\n        \"sequence\": {\n          \"description\": \"The list's `sequence`.\",\n          \"minimum\": 1,\n          \"type\": \"integer\"\n        }\n      },\n      \"required\": [\n        \"sequence\",\n        \"digest\"\n      ],\n      \"title\": \"RevocationHead\",\n      \"type\": \"object\"\n    },\n    \"RevocationList\": {\n      \"additionalProperties\": false,\n      \"description\": \"The room's own statement of which credentials it has withdrawn before they expire — signed by the room, cumulative, and numbered, so that it means the same thing at every host it is delivered to.\\n\\n**Why the room signs it, and why it is cumulative.** A host authorizes from credentials the room issued and keeps no roster; a withdrawal kept only as a host's own state would make the room unmovable and the host part of the membership. A list the room signed is room state: it moves with the room, any host it is delivered to reaches the same decision, and nothing a host invents can be mistaken for it. It is cumulative — every list carries every entry still in force — so a host holding any one list holds the room's whole withdrawal state, and a host that missed a list loses nothing once it receives a later one.\\n\\n**Producing.** The room's key holder builds the object without `proof` and signs it with a W3C Data Integrity proof whose `verificationMethod` is a key the room's DID document lists for `assertionMethod` and whose `proofPurpose` is `assertionMethod`. A producer MUST support `eddsa-jcs-2022`. Each list's `sequence` is exactly one greater than the last list the room signed, and the producer MUST NOT sign two different lists at one `sequence`.\\n\\n**Accepting.** A host MUST refuse a list unless: (1) `roomId` is the room it is delivered for; (2) `proof` verifies with a key of `roomId` listed for `assertionMethod` — a list signed by any other key, however valid the signature, is not the room's; (3) `sequence` is greater than that of the list it holds, or equal with an identical list (a repeat, answered as accepted and changing nothing); (4) it is **append-only** against the list it holds: every entry of the held list appears in it unchanged, unless that entry's `until` has passed. A list that lowers the sequence is a rollback and one that drops a live entry is a reinstatement nobody signed for, and both are refused; two different lists at one `sequence` is the room's key equivocating, and the host keeps the list it holds.\\n\\n**Applying.** A credential is revoked by an accepted list when any entry matches it (see `RevocationEntry`). An entry whose `until` has passed MAY be discarded by a host and omitted from later lists; no other entry is ever dropped.\\n\\n**Size.** A list is bounded at 4096 entries. A room that would exceed it uses a `room` entry, which withdraws everything issued before it and lets the room re-issue to those who remain.\",\n      \"properties\": {\n        \"entries\": {\n          \"description\": \"Every withdrawal still in force, in the order the room made them. Empty is valid: a room that has revoked nothing, or whose every entry has lapsed, can still state its sequence.\",\n          \"items\": {\n            \"$ref\": \"#/$defs/RevocationEntry\"\n          },\n          \"maxItems\": 4096,\n          \"type\": \"array\"\n        },\n        \"issuedAt\": {\n          \"description\": \"When the room signed this list.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"proof\": {\n          \"description\": \"The room's Data Integrity proof over every other member, made with a key the room's DID document lists for `assertionMethod`.\",\n          \"type\": \"object\"\n        },\n        \"roomId\": {\n          \"description\": \"The room whose credentials this list withdraws, exactly as on the wire. Signed, so a list cannot be replayed against another room.\",\n          \"maxLength\": 512,\n          \"minLength\": 1,\n          \"type\": \"string\"\n        },\n        \"sequence\": {\n          \"description\": \"The list's position in the room's sequence: exactly one greater than the last list the room signed. A host accepts only a list whose sequence is above the one it holds, which is what stops a host, a relayer or an attacker holding an old list from rolling the room's withdrawals back.\",\n          \"minimum\": 1,\n          \"type\": \"integer\"\n        }\n      },\n      \"required\": [\n        \"roomId\",\n        \"sequence\",\n        \"issuedAt\",\n        \"entries\",\n        \"proof\"\n      ],\n      \"title\": \"RevocationList\",\n      \"type\": \"object\"\n    },\n    \"RoomRevocation\": {\n      \"additionalProperties\": false,\n      \"description\": \"Withdraws every credential whose `validFrom` is earlier than `revokedAt`, whoever holds it.\",\n      \"properties\": {\n        \"kind\": {\n          \"const\": \"room\"\n        },\n        \"revokedAt\": {\n          \"description\": \"When the room made this withdrawal.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"until\": {\n          \"description\": \"OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"kind\",\n        \"revokedAt\"\n      ],\n      \"title\": \"RoomRevocation\",\n      \"type\": \"object\"\n    },\n    \"SubjectRevocation\": {\n      \"additionalProperties\": false,\n      \"description\": \"Withdraws a party: every credential naming them as subject or issuer whose `validFrom` is earlier than `revokedAt`.\",\n      \"properties\": {\n        \"kind\": {\n          \"const\": \"subject\"\n        },\n        \"revokedAt\": {\n          \"description\": \"When the room made this withdrawal.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        },\n        \"subject\": {\n          \"description\": \"The party withdrawn. Never the room itself.\",\n          \"maxLength\": 2048,\n          \"pattern\": \"^did:\",\n          \"type\": \"string\"\n        },\n        \"until\": {\n          \"description\": \"OPTIONAL. After this instant every credential the entry matches has expired anyway, so a host MAY discard the entry and the room MAY omit it from later lists. Absent means the entry is kept for as long as the room keeps a list.\",\n          \"format\": \"date-time\",\n          \"type\": \"string\"\n        }\n      },\n      \"required\": [\n        \"kind\",\n        \"subject\",\n        \"revokedAt\"\n      ],\n      \"title\": \"SubjectRevocation\",\n      \"type\": \"object\"\n    }\n  },\n  \"$ref\": \"#/$defs/Response\",\n  \"$schema\": \"https://json-schema.org/draft/2020-12/schema\"\n}\n",
    );
}
impl crate::RequestPayload for Payload {
    type Response = Response;
}
/// The extended error codes this specification declares (SPEC §7.3 item 9,
/// §8.5), in declaration order. Empty when it declares none.
pub const ERROR_CODES: &[crate::DeclaredErrorCode] = &[
    error_codes::LIST_INVALID,
    error_codes::STALE,
    error_codes::SEQUENCE_CONFLICT,
    error_codes::NOT_APPEND_ONLY,
    error_codes::ENTRY_NOT_PERMITTED,
];
/// One constant per extended error code this specification declares
/// (SPEC §7.3 item 9), named for its local part.
///
/// Emit these rather than a string literal: the code is read from the
/// specification, so it cannot name a code the specification never
/// declared.
pub mod error_codes {
    /// `rooms/revocations/put:listInvalid`
    ///
    /// The list is not one the room signed for this room: its `roomId` differs from the request's, its proof does not verify with a key the room's DID document lists for `assertionMethod`, or an entry names the room itself as a subject.
    ///
    /// Declared `retryable: false`.
    pub const LIST_INVALID: crate::DeclaredErrorCode = crate::DeclaredErrorCode {
        code: "rooms/revocations/put:listInvalid",
        retryable: false,
        details_schema: ::core::option::Option::None,
    };
    /// `rooms/revocations/put:stale`
    ///
    /// The list's sequence is below that of the list the host holds. Nothing changed. The held sequence is carried in `details.heldSequence`, so the key holder learns the host is ahead of what it delivered.
    ///
    /// Declared `retryable: false`.
    /// Declares a `detailsSchema` for the error's `details` member.
    pub const STALE: crate::DeclaredErrorCode = crate::DeclaredErrorCode {
        code: "rooms/revocations/put:stale",
        retryable: false,
        details_schema: ::core::option::Option::Some(
            "{\"additionalProperties\":false,\"properties\":{\"heldSequence\":{\"minimum\":1,\"type\":\"integer\"}},\"required\":[\"heldSequence\"],\"type\":\"object\"}",
        ),
    };
    /// `rooms/revocations/put:sequenceConflict`
    ///
    /// The host holds a different list at the same sequence. The room has signed two lists at one position — its key holder has forked, or its key is in more than one party's hands. Nothing changed: the host keeps the list it holds.
    ///
    /// Declared `retryable: false`.
    pub const SEQUENCE_CONFLICT: crate::DeclaredErrorCode = crate::DeclaredErrorCode {
        code: "rooms/revocations/put:sequenceConflict",
        retryable: false,
        details_schema: ::core::option::Option::None,
    };
    /// `rooms/revocations/put:notAppendOnly`
    ///
    /// The list omits an entry of the held list whose `until` has not passed. A withdrawal is never undone by omission; a room re-admits a party by issuing fresh credentials, which a `subject` or `room` entry does not reach.
    ///
    /// Declared `retryable: false`.
    pub const NOT_APPEND_ONLY: crate::DeclaredErrorCode = crate::DeclaredErrorCode {
        code: "rooms/revocations/put:notAppendOnly",
        retryable: false,
        details_schema: ::core::option::Option::None,
    };
    /// `rooms/revocations/put:entryNotPermitted`
    ///
    /// The room is `private` and the list carries a `credential` or `subject` entry, which a host cannot apply there and which would disclose who was in the room.
    ///
    /// Declared `retryable: false`.
    pub const ENTRY_NOT_PERMITTED: crate::DeclaredErrorCode = crate::DeclaredErrorCode {
        code: "rooms/revocations/put:entryNotPermitted",
        retryable: false,
        details_schema: ::core::option::Option::None,
    };
}