Struct min_jwt::BasicClaims

#[non_exhaustive]
pub struct BasicClaims<'a> {
    pub iss: Option<&'a str>,
    pub iat: Option<u64>,
    pub exp: Option<u64>,
    pub aud: Option<&'a str>,
    pub sub: Option<&'a str>,
}

Contains the issuer ID, when the token was issued, and when the token expires.

The BasicClaims type is intended to be used for generic algorithms which only require common information in JWTs. For most applications, a custom application specific type would be required to deserialize all of the fields.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

iss: Option<&'a str>

The issuer of the token.

iat: Option<u64>

When the token was issued as the number of seconds since the Unix epoch.

exp: Option<u64>

When the token should expire as the number of seconds since the Unix epoch.

aud: Option<&'a str>

The intended audience.

sub: Option<&'a str>

The subject.

Trait Implementations

impl<'a> Clone for BasicClaims<'a>

fn clone(&self) -> BasicClaims<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BasicClaims<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for BasicClaims<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> PartialEq for BasicClaims<'a>

fn eq(&self, other: &BasicClaims<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Serialize for BasicClaims<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Claims for BasicClaims<'a>

impl<'a> Eq for BasicClaims<'a>

impl<'a> StructuralEq for BasicClaims<'a>

impl<'a> StructuralPartialEq for BasicClaims<'a>