Enum DisclosableEntry 

pub enum DisclosableEntry<T> {
    Disclosed(T),
    Reference {
        hash: String,
    },
}

An entry inside an allowed or line_items constraint.

In Autonomous mode the specification makes these entries individually disclosable: each is its own SD-JWT disclosure, referenced from the constraint object by hash. An agent presents only the entries a given verifier needs, so the remainder arrive as {"...": "<hash>"}.

Both forms have to survive parsing. A reference is not an error, and it is not a value either — it is an entry this presentation deliberately withheld, and a verifier that cannot tell the two apart cannot reason about either. Nothing here resolves a reference; resolution needs the presentation’s disclosure set, which lives above this layer.

Variants

Disclosed(T)

The entry’s value, disclosed in this presentation.

Reference

An entry withheld from this presentation, kept as its disclosure hash.

Fields

hash: String

Implementations

impl<T> DisclosableEntry<T>

pub fn disclosed(&self) -> Option<&T>

The entry’s value, or None when it was withheld.

Callers that evaluate a constraint use this: an undisclosed entry cannot take part in a decision, because its contents are unknown.

Trait Implementations

impl<T: Clone> Clone for DisclosableEntry<T>

fn clone(&self) -> DisclosableEntry<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for DisclosableEntry<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for DisclosableEntry<T>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T: Eq> Eq for DisclosableEntry<T>

impl<T: PartialEq> PartialEq for DisclosableEntry<T>

fn eq(&self, other: &DisclosableEntry<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Serialize> Serialize for DisclosableEntry<T>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T: PartialEq> StructuralPartialEq for DisclosableEntry<T>