Struct AuthMethod 

pub struct AuthMethod {
    pub name: Arc<str>,
    pub steps: Vec<FactorStep>,
    pub scope: AuthnScope,
}

An authentication method: a named sequence of factor steps.

Each step is either a required factor or a choice among alternatives.

Examples

Sequential MFA (password then TOTP):

AuthMethod {
    name: "password+totp",
    steps: vec![FactorStep::Required(Password), FactorStep::Required(Totp)],
    ..
}

Factor choice (FIDO2 or password):

AuthMethod {
    name: "passkey-or-password",
    steps: vec![FactorStep::AnyOf(vec![Fido2, Password])],
    ..
}

Fields

name: Arc<str>

Human-readable method name, e.g. "password", "password+totp".

steps: Vec<FactorStep>

Factor steps in the order they must be completed.

Each step is either FactorStep::Required (exactly one factor) or FactorStep::AnyOf (user chooses one from the list).

For backward compatibility, use the factors convenience method if you only need simple sequential flows.

scope: AuthnScope

The scope at which this method is defined.

Implementations

impl AuthMethod

pub fn sequential( name: impl Into<Arc<str>>, factors: Vec<FactorKind>, scope: AuthnScope, ) -> Self

Convenience: create a method from a flat list of required factors (sequential MFA).

pub fn factors(&self) -> Vec<FactorKind>

Return the flat list of factor kinds for simple sequential methods.

For methods using AnyOf steps, this returns the first choice of each AnyOf step; use steps directly for full fidelity.

Trait Implementations

impl Clone for AuthMethod

fn clone(&self) -> AuthMethod

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AuthMethod

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AuthMethod

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AuthMethod

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

where __S: Serializer,

Serialize this value into the given Serde serializer.