Struct Token 

#[non_exhaustive]
pub struct Token {
    pub access_token: SensitiveString,
    pub refresh_token: Option<SensitiveString>,
    pub token_type: String,
    pub expires_in: Option<u64>,
    pub scope: Option<String>,
    pub expires_at: Option<DateTime<Utc>>,
}

A token response. expires_in is a lifetime that starts decaying the moment the server answers, so expires_at is worked out from it on arrival and is the field to keep: a moment stays true however long it is held. The server never sends it, so it defaults to None when it is missing and is written back out with the rest.

The SDK stores nothing itself. Whoever keeps a token between runs stores this or their own shape, and either way carries expires_at with it, or the next run has no idea when the token is spent.

The two tokens are SensitiveStrings: serde-transparent, so the wire is what the server sent, but [REDACTED] under {:?}.

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.

access_token: SensitiveString

What goes in Authorization on every request.

refresh_token: Option<SensitiveString>

What buys the next access token once this one is spent, when the server issued one.

token_type: String

How the access token is presented: Bearer, for HEY.

expires_in: Option<u64>

How many seconds the access token was good for when the server answered.

scope: Option<String>

What the token was granted, when the server said.

expires_at: Option<DateTime<Utc>>

The moment the access token is spent, worked out from expires_in on arrival.

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Token

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Token

impl PartialEq for Token

fn eq(&self, other: &Token) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Token

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Token