Pricing, IV, Greeks,
Volatility.

use ferro_risk::{ExerciseStyle, OptionType, PricingInputs,
             PricingModel, greeks_all};

let inputs = PricingInputs {
    option_type: OptionType::Call,
    exercise_style: ExerciseStyle::European,
    spot: 4_850.0,
    strike: 4_900.0,
    time_to_expiry: 0.25,
    rate: 0.045,
    dividend_yield: 0.0,
    volatility: 0.22,
};

let greeks = greeks_all(&inputs, PricingModel::Black76)?;
// greeks.delta, .gamma, .theta, .vega, .rho,
// .vanna, .volga, .charm, .veta, .color

use ferro_risk::{calibrate_svi_surface, FitQuality,
             SviCalibrationPolicy, SurfaceCalibrationSearchPolicy};

let policy = SviCalibrationPolicy::default()
    .with_search(SurfaceCalibrationSearchPolicy::default());

let report = calibrate_svi_surface(&input, &policy)?;

match report.fit_quality() {
    FitQuality::Healthy => use_parametric(&report),
    FitQuality::Acceptable { reason } => // RR25 / ATM IV /
        readouts_only(&report),       // term-structure
    FitQuality::Degenerate { reason } => // shape-model breakdown
        surface_raw_interpolated_skew(/* … */)?,
    FitQuality::Failed { reason } => bail_or_retry(reason),
    _ => unreachable!(),
}

use ferro_risk::{ChainExposureInputs, ChainExposureMetric,
             PricingModel, derive_chain_exposures, strike_walls};

// chain_state, market, policy set up upstream
let inputs = ChainExposureInputs::new(
    &chain_state, &market,
    PricingModel::BlackScholesMerton, policy)?;
let report = derive_chain_exposures(&inputs)?;

// per-strike GEX, via the metric projection
for b in &report.strike_buckets {
    let gex = ChainExposureMetric::Gex
        .value(b.net_exposure);
}

// OI-side walls — one per metric
let walls = strike_walls(&report);
let call_wall = walls.iter().find(|w|
    w.metric == ChainExposureMetric::OpenInterestCall);

use ferro_risk::{variance_risk_premium, vrp_decomposition,
             JumpDiffusionFit, JumpDiffusionParameters,
             RvMethod, SurfaceTenor};

let tenor = SurfaceTenor::new(30.0 / 365.0)?;

let vrp = variance_risk_premium(
    0.22, 0.18,  // implied, realized vol
    tenor, RvMethod::YangZhang,
)?;

let params =
    JumpDiffusionParameters::new(0.9, -0.02, 0.08);
let fit = JumpDiffusionFit::new(0.18, params)?;
let split = vrp_decomposition(fit, vrp);

// split.diffusive_vrp(), .jump_vrp(),
// split.jump_variance_share()

use ferro_risk::{calibrate_jump_diffusion, jump_prior_cross_check,
             realized_jump_split, JumpAssumption, JumpEstimateUncertainty,
             JumpMeasure, JumpPriorCrossCheckPolicy};

// physical-measure anchor — e.g. ferro-wave's jump detector
let unc = JumpEstimateUncertainty::new(32, 0.68, 0.005, 0.004)?;
let prior = JumpAssumption::new(
    JumpMeasure::Physical, 3.66, -0.082, 0.025, unc)?;

let realized = realized_jump_split(&bars, 252.0)?;
let check = jump_prior_cross_check(&prior, &realized,
    JumpPriorCrossCheckPolicy::new(0.35)?)?;

let outcome = calibrate_jump_diffusion(
    &input, &policy, &prior, Some(check))?;

// outcome.is_confident() · outcome.tilted_assumption()
// outcome.per_expiry()[i].fit() → vrp_decomposition(..)