jsonwebtoken

https://docs.rs/jsonwebtoken/latest/jsonwebtoken/
Admin
jsonwebtoken is a Rust library for creating and parsing JSON Web Tokens (JWTs) with support for...
Tokens:5,658
Snippets:64
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Initialize JWT Validation with Algorithm in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Shows the basic initialization of a `Validation` struct with a specified signing algorithm in Rust. This is the starting point for configuring custom validation rules.

```rust
pub fn new(alg: Algorithm) -> Validation
```

--------------------------------

### Default Validation Configuration (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Provides a default configuration for the `Validation` struct. This is useful for getting a standard set of validation rules when no specific configuration is provided.

```rust
fn default() -> Self
```

--------------------------------

### Get Description of jsonwebtoken Error (Deprecated)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Deprecated method to get a string description of a `jsonwebtoken::Error`. Use the `Display` implementation or `to_string()` instead.

```rust
fn description(&self) -> &str
```

--------------------------------

### Get Cause of jsonwebtoken Error (Deprecated)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Deprecated method to get the lower-level source of a `jsonwebtoken::Error`. Use `source` instead.

```rust
fn cause(&self) -> Option<&dyn StdError>
```

--------------------------------

### Get Source of jsonwebtoken Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Retrieves the underlying error source for a `jsonwebtoken::Error`, if one exists. This is the modern replacement for `cause`.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>
```

--------------------------------

### Rust: Get Current Timestamp

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/index

Retrieves the current timestamp in the format expected by JWT specifications.

```Rust
/// Gets the current timestamp in the format expected by JWTs.
pub fn get_current_timestamp() -> usize
```

--------------------------------

### Get JWT Error Kind

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Retrieves the specific type of error from a `jsonwebtoken::Error` instance. This method is crucial for diagnosing the root cause of a JWT processing failure.

```rust
pub fn kind(&self) -> &ErrorKind
```

--------------------------------

### Get Type ID of a Generic Type (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Retrieves the `TypeId` of a given type `T`. This is part of the `Any` trait implementation, allowing for runtime type identification.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Configure JWT Validation Parameters in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Demonstrates how to create and configure a `Validation` instance in Rust for JWT processing. It shows setting the algorithm, leeway, audience, issuer, and required specific claims.

```rust
use jsonwebtoken::{Validation, Algorithm};

let mut validation = Validation::new(Algorithm::HS256);
validation.leeway = 5;
// Setting audience
validation.set_audience(&["Me"]); // a single string
validation.set_audience(&["Me", "You"]); // array of strings
// or issuer
validation.set_issuer(&["Me"]); // a single string
validation.set_issuer(&["Me", "You"]); // array of strings
// Setting required claims
validation.set_required_spec_claims(&["exp", "iss", "aud"]);
```

--------------------------------

### Compare jsonwebtoken Errors for Equality

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `PartialEq` for `jsonwebtoken::Error`, allowing comparison of two error instances for equality.

```rust
fn eq(&self, other: &Error) -> bool
```

--------------------------------

### Provide Context for jsonwebtoken Error (Nightly)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

An experimental, nightly-only API for providing type-based access to error context, primarily for error reporting.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

--------------------------------

### Enum Algorithm for JWT Signing

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/enum

Defines the supported algorithms for signing and verifying JSON Web Tokens (JWTs). Includes HMAC, ECDSA, RSASSA, and EdDSA variants.

```rust
pub enum Algorithm {
    HS256,
    HS384,
    HS512,
    ES256,
    ES384,
    RS256,
    RS384,
    RS512,
    PS256,
    PS384,
    PS512,
    EdDSA,
}
```

--------------------------------

### Unsafe Clone to Uninitialized Memory (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

🔬 This is a nightly-only experimental API. It performs copy-assignment from `self` to a provided uninitialized memory destination (`dest`). Requires `T: Clone`.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Generic Clone Implementation for Types

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

A blanket implementation of `CloneToUninit` for any type that implements `Clone`, facilitating efficient cloning into uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### jsonwebtoken::crypto::verify Function Signature

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/crypto/fn

This function signature defines the `verify` function within the `jsonwebtoken::crypto` module. It takes the signature, message, decoding key, and algorithm as input and returns a Result indicating success or failure.

```rust
pub fn verify(
    signature: &str,
    message: &[u8],
    key: &DecodingKey,
    algorithm: Algorithm,
) -> Result<bool>
```

--------------------------------

### RSAKeyParameters Structure

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/jwk/struct

Defines the parameters required for an RSA public key within the jsonwebtoken library.

```APIDOC
## Struct RSAKeyParameters

### Description
Parameters for a RSA Key.

### Fields
- **key_type** (RSAKeyType) - Required - Key type value for a RSA Key.
- **n** (String) - Required - The “n” (modulus) parameter contains the modulus value for the RSA public key.
- **e** (String) - Required - The “e” (exponent) parameter contains the exponent value for the RSA public key.

### Request Example
```json
{
  "key_type": "RSA",
  "n": "your_public_modulus_here",
  "e": "your_public_exponent_here"
}
```

### Response Example
```json
{
  "key_type": "RSA",
  "n": "your_public_modulus_here",
  "e": "your_public_exponent_here"
}
```
```

--------------------------------

### Rust: Encode JWT

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/index

Encodes a JWT by signing the payload with the provided header and claims, using the specified algorithm and key. For RSA or EC algorithms, the key must be in PEM format.

```Rust
/// Encode the header and claims given and sign the payload using the algorithm from the header and the key.
/// If the algorithm given is RSA or EC, the key needs to be in the PEM format.
pub fn encode<T: Serialize>(header: &Header, claims: &T, key: &[u8]) -> Result<String, Error>
```

--------------------------------

### RSAKeyType Trait Implementations (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/jwk/enum

Demonstrates various trait implementations for the `RSAKeyType` enum in Rust. These include `Clone`, `Debug`, `Default`, `Deserialize`, `Hash`, `PartialEq`, and `Serialize`, enabling common operations and data handling.

```rust
impl Clone for RSAKeyType
fn clone(&self) -> RSAKeyType

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

impl Default for RSAKeyType
fn default() -> RSAKeyType

impl<'de> Deserialize<'de> for RSAKeyType
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>

impl Hash for RSAKeyType
fn hash<__H: Hasher>(&self, state: &mut __H)
fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized

impl PartialEq for RSAKeyType
fn eq(&self, other: &RSAKeyType) -> bool
fn ne(&self, other: &Rhs) -> bool

impl Serialize for RSAKeyType
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer
```

--------------------------------

### Convert DecodeError to jsonwebtoken Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `From<DecodeError>` for `jsonwebtoken::Error`, enabling conversion from decoding-specific errors.

```rust
fn from(err: DecodeError) -> Error
```

--------------------------------

### Generic Try Conversion via TryInto

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `TryInto<U>` for `T` when `U` implements `TryFrom<T>`, enabling fallible type conversions using `try_into()`.

--------------------------------

### Generic Try Conversion via TryFrom

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `TryFrom<U>` for `T` when `U` implements `Into<T>`, enabling fallible type conversions using `try_from()`.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Format jsonwebtoken Error for Display

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements the `Display` trait for `jsonwebtoken::Error`, providing a user-friendly string representation of the error.

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

--------------------------------

### Clone jsonwebtoken Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Creates a copy of an existing `jsonwebtoken::Error`. This is useful when an error needs to be propagated or handled in multiple places.

```rust
fn clone(&self) -> Error
```

--------------------------------

### Convert KeyRejected to jsonwebtoken Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `From<KeyRejected>` for `jsonwebtoken::Error`, allowing conversion when a cryptographic key is rejected.

```rust
fn from(_err: KeyRejected) -> Error
```

--------------------------------

### Rust: Decode and Validate JWT

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/index

Decodes and validates a JWT using the provided token, validation rules, and decoding key. Handles potential errors during the process.

```Rust
/// Decode and validate a JWT
pub fn decode<T: DeserializeOwned>(
    token: &str,
    key: &[u8],
    algorithm: &'static Algorithm,
    validation: &Validation,
) -> Result<TokenData<T>, Error>
```

--------------------------------

### Clone From Validation Struct (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Enables copy-assignment from a source `Validation` struct to the current one. This is an efficient way to update validation settings.

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

--------------------------------

### Generic String Conversion

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `ToString` for any type that implements `Display`, enabling conversion to a `String` via the `to_string()` method.

```rust
fn to_string(&self) -> String
```

--------------------------------

### Clone Validation Struct (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Provides a method to create a duplicate of the `Validation` struct. This is useful for maintaining separate validation configurations or passing copies of settings.

```rust
fn clone(&self) -> Validation
```

--------------------------------

### Format Validation Struct for Debugging (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Implements the `Debug` trait for the `Validation` struct, allowing it to be formatted for debugging purposes using a provided `Formatter`. This helps in inspecting the state of validation settings.

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

--------------------------------

### Convert FromUtf8Error to jsonwebtoken Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `From<FromUtf8Error>` for `jsonwebtoken::Error`, enabling conversion when UTF-8 decoding fails.

```rust
fn from(err: FromUtf8Error) -> Error
```

--------------------------------

### Clone From jsonwebtoken Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Performs copy-assignment from one `jsonwebtoken::Error` to another. This is an optimization for mutable error handling.

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

--------------------------------

### Clone into Existing Owned Data (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Allows using borrowed data to replace the contents of existing owned data, typically by cloning. This is an efficient way to update owned data.

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### Convert ErrorKind to jsonwebtoken Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `From<ErrorKind>` for `jsonwebtoken::Error`, facilitating the creation of a generic `Error` from a specific `ErrorKind`.

```rust
fn from(kind: ErrorKind) -> Error
```

--------------------------------

### Format jsonwebtoken Error for Debug

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements the `Debug` trait for `jsonwebtoken::Error`, allowing it to be formatted for debugging purposes.

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

--------------------------------

### Equality Check for Validation Structs (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Implements the `PartialEq` trait, allowing for equality comparison between two `Validation` structs using the `==` operator. This checks if all validation parameters are identical.

```rust
fn eq(&self, other: &Validation) -> bool
```

--------------------------------

### Compare jsonwebtoken Errors for Inequality

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements the `!=` operator for `jsonwebtoken::Error`, providing a convenient way to check for inequality between errors.

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

--------------------------------

### Generic Identity Conversion

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `From<T>` for `T`, allowing a value to be converted into itself.

```rust
fn from(t: T) -> T
```

--------------------------------

### Convert jsonwebtoken Error to itself

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `From<Error>` for `jsonwebtoken::Error`, allowing an error to be converted into itself.

```rust
fn from(err: Error) -> Error
```

--------------------------------

### Convert Unspecified Error to jsonwebtoken Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `From<Unspecified>` for `jsonwebtoken::Error`, used for converting unspecified error types.

```rust
fn from(err: Unspecified) -> Error
```

--------------------------------

### Generic Conversion via From Trait

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `Into<U>` for `T` when `U` implements `From<T>`, enabling type conversions using the `into()` method.

```rust
fn into(self) -> U
```

--------------------------------

### Set Required Specific Claims for JWT Validation in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Explains how to define which specific claims (`exp`, `nbf`, `aud`, `iss`, `sub`) are mandatory for a JWT to be considered valid using `set_required_spec_claims`. This method accepts a slice of strings representing the required claim names.

```rust
pub fn set_required_spec_claims<T: ToString>(&mut self, items: &[T])
```

--------------------------------

### Unwrap JWT Error to Kind

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Consumes the `jsonwebtoken::Error` and returns its underlying `ErrorKind`. This allows for direct handling of the specific error variant.

```rust
pub fn into_kind(self) -> ErrorKind
```

--------------------------------

### Define JWT Validation Settings in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Defines the `Validation` struct used for JWT validation in Rust. This struct holds various settings to control how a JWT is validated, including required claims, leeway for time-based validations, and specific fields like audience and issuer.

```rust
pub struct Validation {
    pub required_spec_claims: HashSet<String>,
    pub leeway: u64,
    pub reject_tokens_expiring_in_less_than: u64,
    pub validate_exp: bool,
    pub validate_nbf: bool,
    pub validate_aud: bool,
    pub aud: Option<HashSet<String>>,
    pub iss: Option<HashSet<String>>,
    pub sub: Option<String>,
    pub algorithms: Vec<Algorithm>,
    /* private fields */
}
```

--------------------------------

### Generic Owned Data Creation

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements `ToOwned` for types that implement `Clone`, allowing the creation of owned data from borrowed references, typically by cloning.

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### Try Convert Type via Into (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Enables attempting a conversion from type `U` to type `T` using `T::try_from(value)`. This conversion can fail, returning a `Result`.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Define RSAKeyParameters Struct in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/jwk/struct

Defines the RSAKeyParameters struct used to hold parameters for an RSA Key. It includes the key type, modulus (n), and exponent (e). This struct supports common Rust traits like Clone, Debug, Default, Serialize, and Deserialize.

```Rust
pub struct RSAKeyParameters {
    pub key_type: RSAKeyType,
    pub n: String,
    pub e: String,
}
```

--------------------------------

### Set Allowed Issuers for JWT Validation in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Demonstrates how to specify the allowed issuer(s) for a JWT using the `set_issuer` method. This method can take a single string or a slice of strings as valid issuer identifiers.

```rust
pub fn set_issuer<T: ToString>(&mut self, items: &[T])
```

--------------------------------

### Rust: Decode JWT Header

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/index

Decodes a JWT's header without performing any signature verification or validations. Returns the Header struct.

```Rust
/// Decode a JWT without any signature verification/validations and return its Header.
pub fn decode_header(token: &str) -> Result<Header, Error>
```

--------------------------------

### Identity Conversion (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Implements the `From` trait for a type `T` to itself, meaning the conversion simply returns the argument unchanged. This is a trivial conversion.

```rust
fn from(t: T) -> T
```

--------------------------------

### Convert Type via From (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Enables conversion from type `T` to type `U` by calling `U::from(self)`. This relies on the `From<T> for U` implementation defining the conversion logic.

```rust
fn into(self) -> U
```

--------------------------------

### Set Allowed Audiences for JWT Validation in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Illustrates how to set the allowed audience(s) for a JWT using the `set_audience` method. This method accepts either a single string or an array of strings representing valid audience members.

```rust
pub fn set_audience<T: ToString>(&mut self, items: &[T])
```

--------------------------------

### JWT Conversion Function in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Implements the `try_into` method for performing JWT conversions. It returns a `Result` which is either the converted type `U` on success or the associated error type on failure.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Inequality Check for Validation Structs (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Implements the `PartialEq` trait for inequality comparison between `Validation` structs using the `!=` operator. This is typically derived and should not be overridden without strong justification.

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

--------------------------------

### Try Convert Type via TryFrom (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Enables attempting a conversion from type `T` to type `U` using `U::try_from(self)`. This conversion can fail, returning a `Result` with the specified error type.

```rust
type Error = <U as TryFrom<T>>::Error
```

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### jsonwebtoken Error Struct Definition

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Defines the `Error` struct used for handling errors during JWT operations. It contains private fields to encapsulate error details.

```rust
pub struct Error(/* private fields */);
```

--------------------------------

### RSAKeyType Enum Definition (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/jwk/enum

Defines the `RSAKeyType` enum, used to represent RSA key types. This enum is a workaround for Rust's limitations with associated constants. It has a single variant, `RSA`.

```rust
pub enum RSAKeyType {
    RSA,
}
```

--------------------------------

### Create Owned Data from Borrowed Data (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Defines an associated type `Owned` which is the type that owns the data, and provides a method `to_owned` to create owned data, usually by cloning from borrowed data.

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

--------------------------------

### jsonwebtoken::errors::Error

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

The primary Error struct for JWT operations. It encapsulates various types of errors that can occur during encoding or decoding.

```APIDOC
## Struct Error

### Description
An error that can occur when encoding/decoding JWTs.

### Method
`pub fn kind(&self) -> &ErrorKind`

### Description
Return the specific type of this error.

### Method
`pub fn into_kind(self) -> ErrorKind`

### Description
Unwrap this error into its underlying type.

### Implementations

#### `impl Clone for Error`

##### `fn clone(&self) -> Error`
Returns a duplicate of the value.

##### `fn clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

#### `impl Debug for Error`

#### `impl Display for Error`

#### `impl Error for Error`

##### `fn source(&self) -> Option<&(dyn Error + 'static)>`
Returns the lower-level source of this error, if any.

##### `fn provide<'a>(&'a self, request: &mut Request<'a>)`
Provides type-based access to context intended for error reports.

#### `impl From<DecodeError> for Error`

#### `impl From<ErrorKind> for Error`

#### `impl From<FromUtf8Error> for Error`

#### `impl From<KeyRejected> for Error`

#### `impl From<Unspecified> for Error`

#### `impl PartialEq for Error`

##### `fn eq(&self, other: &Error) -> bool`
Tests for `self` and `other` values to be equal, and is used by `==`.

##### `fn ne(&self, other: &Rhs) -> bool`
Tests for `!=`.

#### `impl Eq for Error`

#### `impl StructuralPartialEq for Error`
```

--------------------------------

### DeserializeOwned Trait Implementation for JWT

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/enum

Implements the `DeserializeOwned` trait for generic types `T` where `T` itself can be deserialized from any lifetime. This is crucial for parsing JWT payloads into Rust structs.

```rust
impl<T> DeserializeOwned for T
where
    T: for<'de> Deserialize<'de>,
```

--------------------------------

### Immutable Borrow of a Value (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Provides an immutable reference to an owned value. This is a fundamental operation for accessing data without modification.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### Mutable Borrow of a Value (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Provides a mutable reference to an owned value, allowing for in-place modification. This is crucial for updating data structures.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### JWT Conversion Error Type in Rust

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/struct

Defines the generic `Error` type for JWT conversion failures, dependent on the `TryFrom` trait implementation. This type signifies the specific error encountered during the conversion process.

```rust
type Error = <U as TryFrom<T>>::Error
```

--------------------------------

### Rust: JWT ErrorKind Enum Definition

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/errors/enum

Defines the `ErrorKind` enum, which represents specific types of errors encountered during JSON Web Token (JWT) operations. It includes variants for token validation failures, signature issues, key problems, and encoding/decoding errors. The enum is marked as non-exhaustive to allow for future additions.

```rust
#[non_exhaustive]
pub enum ErrorKind {
    InvalidToken,
    InvalidSignature,
    InvalidEcdsaKey,
    InvalidRsaKey(String),
    RsaFailedSigning,
    InvalidAlgorithmName,
    InvalidKeyFormat,
    MissingRequiredClaim(String),
    ExpiredSignature,
    InvalidIssuer,
    InvalidAudience,
    InvalidSubject,
    ImmatureSignature,
    InvalidAlgorithm,
    MissingAlgorithm,
    Base64(DecodeError),
    Json(Arc<Error>),
    Utf8(FromUtf8Error),
    Crypto(Unspecified),
}
```

--------------------------------

### Disable Signature Validation in JWT (Rust)

Source: https://docs.rs/jsonwebtoken/latest/jsonwebtoken/struct

Allows disabling JWT signature validation, which is a dangerous operation. Use with extreme caution as it means claims should not be trusted. This function is part of the JWT validation configuration.

```rust
pub fn insecure_disable_signature_validation(&mut self)
```
Tokens:
Raw