Struct DeviceFlowConfig

pub struct DeviceFlowConfig {

    pub client_id: String,
    pub client_secret: Option<Secret<String>>,
    pub scopes: Vec<String>,
    pub redirect_uri: Option<Url>,
    pub poll_interval: Duration,
    pub max_attempts: u32,
    pub backoff_multiplier: f64,
    pub max_poll_interval: Duration,
    pub user_agent: Option<String>,
    pub additional_headers: HashMap<String, String>,
    pub generic_provider_config: Option<GenericProviderConfig>,
    pub request_timeout: Duration,
    pub use_pkce: Option<bool>,
}

Configuration for the device flow

Fields

client_id: String

OAuth client ID

client_secret: Option<Secret<String>>

OAuth client secret (optional, required for some providers)

scopes: Vec<String>

Requested scopes

redirect_uri: Option<Url>

Custom redirect URI (optional)

poll_interval: Duration

Polling interval

max_attempts: u32

Maximum number of polling attempts

backoff_multiplier: f64

Exponential backoff multiplier for polling

max_poll_interval: Duration

Maximum polling interval (for backoff)

user_agent: Option<String>

Custom user agent for HTTP requests

additional_headers: HashMap<String, String>

Additional headers to send with requests

generic_provider_config: Option<GenericProviderConfig>

Configuration for generic providers

request_timeout: Duration

Timeout for HTTP requests

use_pkce: Option<bool>

Whether to use PKCE (Proof Key for Code Exchange)

Implementations

impl DeviceFlowConfig

pub fn new() -> Self

Create a new configuration with defaults

pub fn client_id(self, client_id: impl Into<String>) -> Self

Set the client ID

pub fn client_secret(self, client_secret: impl Into<String>) -> Self

Set the client secret

pub fn scopes<I, S>(self, scopes: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Set the scopes

pub fn scope(self, scope: impl Into<String>) -> Self

Add a scope

pub fn redirect_uri(self, uri: impl Into<String>) -> Result<Self, ParseError>

Set the redirect URI

pub fn poll_interval(self, interval: Duration) -> Self

Set the polling interval

pub fn max_attempts(self, attempts: u32) -> Self

Set the maximum number of polling attempts

pub fn backoff_multiplier(self, multiplier: f64) -> Self

Set the exponential backoff multiplier

pub fn max_poll_interval(self, interval: Duration) -> Self

Set the maximum polling interval

pub fn user_agent(self, user_agent: impl Into<String>) -> Self

Set a custom user agent

pub fn header(self, key: impl Into<String>, value: impl Into<String>) -> Self

Add an additional header

pub fn generic_provider(self, config: GenericProviderConfig) -> Self

Set the generic provider configuration

pub fn request_timeout(self, timeout: Duration) -> Self

Set the HTTP request timeout

pub fn use_pkce(self, use_pkce: bool) -> Self

Enable or disable PKCE

pub fn effective_scopes(&self, provider: Provider) -> Vec<String>

Get the effective scopes for a provider

pub fn effective_poll_interval(&self, provider: Provider) -> Duration

Get the effective polling interval for a provider

pub fn should_use_pkce(&self, provider: Provider) -> bool

Check if PKCE should be used for a provider

pub fn requires_client_secret(&self, provider: Provider) -> bool

Check if client secret is required for a provider

pub fn validate(&self, provider: Provider) -> Result<(), DeviceFlowError>

Validate the configuration for a specific provider

Trait Implementations

impl Clone for DeviceFlowConfig

fn clone(&self) -> DeviceFlowConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeviceFlowConfig

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

Formats the value using the given formatter.

impl Default for DeviceFlowConfig

fn default() -> Self

Returns the “default value” for a type.