Enum ValidationOutcome 

pub enum ValidationOutcome {
    Ok {
        contract: TokenContract,
        consumed: bool,
        effective_ttl: Duration,
    },
    Rejected(TokenLifecycleError),
}

Outcome of a TokenValidator::validate call.

The validator always returns a ValidationOutcome — never a Result — so the caller can branch on the outcome without unwrapping. The error path embeds the structured InvalidationReason for diagnostic routing.

Example

use stygian_charon::token_lifecycle::{
    ChallengeClass, TokenContract, TokenPolicyTable, TokenValidator,
    ValidationOutcome,
};
use stygian_charon::vendor_classifier::VendorId;
use std::time::Duration;

let validator = TokenValidator::with_defaults(TokenPolicyTable::with_builtin_defaults());
let contract = TokenContract {
    token_id: "x".to_string(),
    issued_at_unix_secs: 0,
    ttl: Duration::from_mins(5),
    nonce: "n".to_string(),
    vendor_family: VendorId::Cloudflare,
    challenge_class: ChallengeClass::Interstitial,
    single_use: true,
    bound_session: None,
    description: String::new(),
};
let outcome = validator.validate(&contract, None, 60);
assert!(matches!(outcome, ValidationOutcome::Ok { .. }));

Variants

Ok

Validator accepted the submission.

Fields

contract: TokenContract

Contract that was accepted (with the TTL the validator actually applied — possibly clamped to the per-vendor max_ttl).

consumed: bool

true when the nonce was newly observed by this submission (i.e. the validator marked it consumed). false for multi-use tokens whose nonce was already in the NonceBook.

effective_ttl: Duration

Effective TTL the validator applied after clamping.

Rejected(TokenLifecycleError)

Validator rejected the submission. The error carries the structured InvalidationReason and a human-readable message suitable for operator logs.

Implementations

impl ValidationOutcome

pub const fn is_ok(&self) -> bool

true when the validator accepted the submission.

Example

use stygian_charon::token_lifecycle::{ValidationOutcome};

let outcome = ValidationOutcome::Ok {
    contract: stygian_charon::token_lifecycle::TokenContract {
        token_id: "x".to_string(),
        issued_at_unix_secs: 0,
        ttl: std::time::Duration::from_mins(1),
        nonce: "n".to_string(),
        vendor_family: stygian_charon::vendor_classifier::VendorId::Unknown,
        challenge_class: stygian_charon::token_lifecycle::ChallengeClass::None,
        single_use: false,
        bound_session: None,
        description: String::new(),
    },
    consumed: true,
    effective_ttl: std::time::Duration::from_mins(1),
};
assert!(outcome.is_ok());

pub const fn is_rejected(&self) -> bool

true when the validator rejected the submission.

pub const fn error(&self) -> Option<&TokenLifecycleError>

Borrow the underlying error when Rejected.

pub fn invalidation_kind(&self) -> Option<InvalidationKind>

Invalidation kind when Rejected.

Trait Implementations

impl Clone for ValidationOutcome

fn clone(&self) -> ValidationOutcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValidationOutcome

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

Formats the value using the given formatter.

impl Eq for ValidationOutcome

impl PartialEq for ValidationOutcome

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for ValidationOutcome