commerce_theory/

validation.rs

//! Executable validators for converting raw boundary data into safe records.

use crate::*;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawCartLine {
    pub sku: Sku,
    pub price: Money,
    pub cost: Money,
    pub quantity: Quantity,
    pub discount: Money,
    pub weight: Weight,
}

pub fn validate_cart_line(raw: RawCartLine) -> Result<CartLine, ValidationError> {
    CartLine::try_new(
        raw.sku,
        raw.price,
        raw.cost,
        raw.quantity,
        raw.discount,
        raw.weight,
    )
    .map_err(|_| ValidationError::LineDiscountExceedsGross)
}

#[must_use]
pub fn cart_line_matches_raw(raw: &RawCartLine, line: &CartLine) -> bool {
    line.sku() == raw.sku
        && line.price() == raw.price
        && line.cost() == raw.cost
        && line.quantity() == raw.quantity
        && line.discount() == raw.discount
        && line.weight() == raw.weight
}

pub fn validate_cart_lines(raw: Vec<RawCartLine>) -> Result<Vec<CartLine>, ValidationError> {
    raw.into_iter().map(validate_cart_line).collect()
}

#[must_use]
pub fn cart_lines_match_raw(raw: &[RawCartLine], lines: &[CartLine]) -> bool {
    raw.len() == lines.len()
        && raw
            .iter()
            .zip(lines)
            .all(|(raw, line)| cart_line_matches_raw(raw, line))
}

#[derive(Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawOrder {
    pub id: OrderId,
    pub items: Vec<RawCartLine>,
    pub coupon_amount: Money,
    pub shipping_method: ShippingMethod,
    pub tax: Money,
    pub currency: Currency,
    pub status: OrderStatus,
    pub total: Money,
}

pub fn validate_order(raw: RawOrder) -> Result<Order, ValidationError> {
    let items = validate_cart_lines(raw.items)?;
    if raw.coupon_amount > cart_net_total(&items)? {
        return Err(ValidationError::CouponExceedsSubtotal);
    }
    if !shipping_available(&raw.shipping_method, cart_weight_total(&items)?) {
        return Err(ValidationError::ShippingUnavailable);
    }
    let expected = order_total(&raw.shipping_method, raw.coupon_amount, raw.tax, &items)?;
    if raw.total != expected {
        return Err(ValidationError::OrderTotalMismatch);
    }
    Order::try_new(
        raw.id,
        items,
        raw.coupon_amount,
        raw.shipping_method,
        raw.tax,
        raw.currency,
        raw.status,
        raw.total,
    )
}

#[must_use]
pub fn order_matches_raw(raw: &RawOrder, order: &Order) -> bool {
    order.id() == raw.id
        && cart_lines_match_raw(&raw.items, order.items())
        && order.coupon_amount() == raw.coupon_amount
        && order.shipping_method() == &raw.shipping_method
        && order.tax() == raw.tax
        && order.currency() == raw.currency
        && order.status() == raw.status
        && order.total() == raw.total
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawStockState {
    pub sku: Sku,
    pub total: Quantity,
    pub reserved: Quantity,
}

pub fn validate_stock_state(raw: RawStockState) -> Result<StockState, ValidationError> {
    StockState::try_new(raw.sku, raw.total, raw.reserved)
        .map_err(|_| ValidationError::StockReservedExceedsTotal)
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawChannelPricePolicy {
    pub min_price: Money,
    pub max_price: Money,
}

pub fn validate_channel_price_policy(
    raw: RawChannelPricePolicy,
) -> Result<ChannelPricePolicy, ValidationError> {
    ChannelPricePolicy::try_new(raw.min_price, raw.max_price)
        .map_err(|_| ValidationError::PricePolicyInvalid)
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawProductFeedLine {
    pub sku: Sku,
    pub channel: SalesChannel,
    pub price: Money,
    pub currency: Currency,
    pub stock: Quantity,
    pub stock_state: RawStockState,
    pub price_policy: RawChannelPricePolicy,
}

pub fn validate_feed_line(raw: RawProductFeedLine) -> Result<SafeProductFeedLine, ValidationError> {
    let stock_state = validate_stock_state(raw.stock_state)?;
    let price_policy = validate_channel_price_policy(raw.price_policy)?;
    if raw.sku != stock_state.sku() {
        return Err(ValidationError::FeedSkuMismatch);
    }
    if !valid_channel_price(&price_policy, raw.price) {
        return Err(ValidationError::FeedPriceOutOfPolicy);
    }
    if raw.stock > available_stock(&stock_state) {
        return Err(ValidationError::FeedStockUnavailable);
    }
    SafeProductFeedLine::try_new(
        raw.sku,
        raw.channel,
        raw.price,
        raw.currency,
        raw.stock,
        stock_state,
        price_policy,
    )
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawPaymentLedger {
    pub captured: Money,
    pub refunded: Money,
}

pub fn validate_payment_ledger(raw: RawPaymentLedger) -> Result<PaymentLedger, ValidationError> {
    PaymentLedger::try_new(raw.captured, raw.refunded)
        .map_err(|_| ValidationError::LedgerRefundedExceedsCaptured)
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawRefund {
    pub amount: Money,
}

#[derive(Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ValidRefund {
    pub(crate) ledger: PaymentLedger,
    pub(crate) amount: Money,
}

impl ValidRefund {
    #[must_use]
    pub const fn ledger(&self) -> &PaymentLedger {
        &self.ledger
    }

    #[must_use]
    pub const fn amount(&self) -> Money {
        self.amount
    }
}

pub fn validate_refund(
    raw: RawRefund,
    ledger: PaymentLedger,
) -> Result<ValidRefund, ValidationError> {
    if !can_refund(&ledger, raw.amount) {
        return Err(ValidationError::RefundExceedsRemaining);
    }
    Ok(ValidRefund {
        ledger,
        amount: raw.amount,
    })
}

pub fn issue_valid_refund(refund: &ValidRefund) -> DomainResult<PaymentLedger> {
    issue_refund(&refund.ledger, refund.amount)
}

pub fn validate_basis_points(value: Nat) -> Result<BasisPoints, ValidationError> {
    BasisPoints::try_new(value).map_err(|_| ValidationError::BasisPointsOutOfRange)
}

pub fn validate_product_catalog_entry(
    product: Product,
    variant: ProductVariant,
) -> Result<ProductCatalogEntry, ValidationError> {
    ProductCatalogEntry::try_new(product, variant)
        .map_err(|_| ValidationError::CatalogInvariantFailed)
}

pub fn validate_listing_content(
    content: ListingContent,
    policy: MarketplaceContentPolicy,
) -> Result<ValidListingContent, ValidationError> {
    ValidListingContent::try_new(content, policy)
        .map_err(|_| ValidationError::CatalogInvariantFailed)
}

pub fn validate_versioned_stock(
    raw: RawStockState,
    version: Nat,
) -> Result<VersionedStock, ValidationError> {
    let stock = validate_stock_state(raw)?;
    Ok(VersionedStock::from_stock(stock, version))
}

pub fn validate_pick_task(
    sku: Sku,
    requested: Quantity,
    bin: BinStock,
) -> Result<PickTask, ValidationError> {
    PickTask::try_new(sku, requested, bin).map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_pack_task(
    source_quantity: Quantity,
    packed_quantity: Quantity,
) -> Result<PackTask, ValidationError> {
    PackTask::try_new(source_quantity, packed_quantity)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_warehouse_shipment(
    packed: Quantity,
    shipped: Quantity,
) -> Result<WarehouseShipment, ValidationError> {
    WarehouseShipment::try_new(packed, shipped)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_allocation(
    node: InventoryNode,
    quantity: Quantity,
) -> Result<Allocation, ValidationError> {
    Allocation::try_new(node, quantity).map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_fulfillment_plan(
    requested: Quantity,
    allocations: Vec<Allocation>,
) -> Result<FulfillmentPlan, ValidationError> {
    FulfillmentPlan::try_new(requested, allocations)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_distinct_fulfillment_plan(
    requested: Quantity,
    allocations: Vec<Allocation>,
) -> Result<DistinctFulfillmentPlan, ValidationError> {
    DistinctFulfillmentPlan::try_new(requested, allocations)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawReservationAttempt {
    pub stock: RawStockState,
    pub version: Nat,
    pub quantity: Quantity,
    pub expected_version: Nat,
}

pub fn validate_raw_reservation_attempt(
    raw: RawReservationAttempt,
) -> Result<ReservationAttempt, ValidationError> {
    Ok(ReservationAttempt::new(
        validate_versioned_stock(raw.stock, raw.version)?,
        raw.quantity,
        raw.expected_version,
    ))
}

pub fn validate_compare_and_swap_reservation(
    stock: VersionedStock,
    quantity: Quantity,
    expected_version: Nat,
) -> Result<VersionedStock, ValidationError> {
    compare_and_swap_reserve(&stock, quantity, expected_version)
        .ok_or(ValidationError::InventoryInvariantFailed)
}

pub fn validate_raw_compare_and_swap_reservation(
    raw: RawReservationAttempt,
) -> Result<VersionedStock, ValidationError> {
    let attempt = validate_raw_reservation_attempt(raw)?;
    validate_compare_and_swap_reservation(
        attempt.stock(),
        attempt.quantity(),
        attempt.expected_version(),
    )
}

pub fn validate_release_reserved_stock(
    stock: StockState,
    quantity: Quantity,
) -> Result<StockState, ValidationError> {
    release_reserved_stock(&stock, quantity).map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_confirm_reserved_shipment(
    stock: StockState,
    quantity: Quantity,
) -> Result<StockState, ValidationError> {
    confirm_reserved_shipment(&stock, quantity)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_timed_reservation(
    stock: StockState,
    quantity: Quantity,
    reserved_at: Timestamp,
    expires_at: Timestamp,
    status: ReservationStatus,
) -> Result<TimedReservation, ValidationError> {
    TimedReservation::try_new(stock, quantity, reserved_at, expires_at, status)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_release_expired_reservation(
    reservation: TimedReservation,
    now: Timestamp,
) -> Result<StockState, ValidationError> {
    release_expired_reservation(&reservation, now)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_backorder_request(
    sku: Sku,
    requested: Quantity,
    available_now: Quantity,
    backordered: Quantity,
) -> Result<BackorderRequest, ValidationError> {
    BackorderRequest::try_new(sku, requested, available_now, backordered)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_preorder_window(
    sku: Sku,
    opens_at: Timestamp,
    closes_at: Timestamp,
    capacity: Quantity,
) -> Result<PreorderWindow, ValidationError> {
    PreorderWindow::try_new(sku, opens_at, closes_at, capacity)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_preorder_reservation(
    window: PreorderWindow,
    quantity: Quantity,
    reserved_at: Timestamp,
) -> Result<PreorderReservation, ValidationError> {
    PreorderReservation::try_new(window, quantity, reserved_at)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_serialized_inventory_set(
    units: Vec<SerializedInventoryUnit>,
) -> Result<SerializedInventorySet, ValidationError> {
    SerializedInventorySet::try_new(units).map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_usable_inventory_lot(
    lot: InventoryLot,
    now: Timestamp,
) -> Result<InventoryLot, ValidationError> {
    if lot_usable_at(now, &lot) {
        Ok(lot)
    } else {
        Err(ValidationError::InventoryInvariantFailed)
    }
}

pub fn validate_sku_substitution(
    requested_sku: Sku,
    substitute_sku: Sku,
    substitute_stock: StockState,
    max_substitute_qty: Quantity,
) -> Result<SkuSubstitution, ValidationError> {
    SkuSubstitution::try_new(
        requested_sku,
        substitute_sku,
        substitute_stock,
        max_substitute_qty,
    )
    .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub fn validate_split_fulfillment_plan(
    plan: DistinctFulfillmentPlan,
    first_warehouse: Warehouse,
    second_warehouse: Warehouse,
) -> Result<SplitFulfillmentPlan, ValidationError> {
    SplitFulfillmentPlan::try_new(plan, first_warehouse, second_warehouse)
        .map_err(|_| ValidationError::InventoryInvariantFailed)
}

pub const fn validate_typed_order<S: OrderStatusMarker>(
    id: OrderId,
    total: Money,
    currency: Currency,
) -> Result<TypedOrder<S>, ValidationError> {
    TypedOrder::try_new(id, total, currency)
}

pub const fn validate_typed_payment<S: PaymentStateMarker>(
    id: PaymentId,
    order_id: OrderId,
    amount: Money,
    currency: Currency,
) -> Result<TypedPayment<S>, ValidationError> {
    TypedPayment::try_new(id, order_id, amount, currency)
}

pub fn validate_balanced_journal_entry(
    postings: Vec<Posting>,
) -> Result<BalancedJournalEntry, ValidationError> {
    BalancedJournalEntry::try_new(postings).map_err(|_| ValidationError::AccountingInvariantFailed)
}

pub fn validate_synced_marketplace_listing(
    listing: MarketplaceListing,
    stock: StockState,
) -> Result<SyncedMarketplaceListing, ValidationError> {
    SyncedMarketplaceListing::try_new(listing, stock)
        .map_err(|_| ValidationError::MarketplaceInvariantFailed)
}

pub fn validate_marketplace_fee_ledger(
    gross: Money,
    fee_rate: BasisPoints,
    fee_rounding_mode: RoundingMode,
    fee: Money,
    payout: Money,
) -> Result<MarketplaceFeeLedger, ValidationError> {
    MarketplaceFeeLedger::try_new(gross, fee_rate, fee_rounding_mode, fee, payout)
        .map_err(|_| ValidationError::MarketplaceInvariantFailed)
}

pub fn validate_marketplace_payout_calculation(
    gross: Money,
    payout_rate: BasisPoints,
    payout_rounding_mode: RoundingMode,
    payout: Money,
) -> Result<MarketplacePayoutCalculation, ValidationError> {
    MarketplacePayoutCalculation::try_new(gross, payout_rate, payout_rounding_mode, payout)
        .map_err(|_| ValidationError::MarketplaceInvariantFailed)
}

pub fn validate_marketplace_order(
    marketplace: Marketplace,
    external_order_id: MarketplaceOrderId,
    internal_order: Order,
    gross_from_marketplace: Money,
    fee_ledger: MarketplaceFeeLedger,
) -> Result<MarketplaceOrder, ValidationError> {
    MarketplaceOrder::try_new(
        marketplace,
        external_order_id,
        internal_order,
        gross_from_marketplace,
        fee_ledger,
    )
    .map_err(|_| ValidationError::MarketplaceInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_marketing_campaign(
    id: CampaignId,
    platform: AdPlatform,
    ad_type: AdType,
    destination: AdDestination,
    status: CampaignStatus,
    budget: Money,
    spend: Money,
    impressions: Nat,
    clicks: Nat,
    conversions: Nat,
    attributed_revenue: Money,
) -> Result<MarketingCampaign, ValidationError> {
    MarketingCampaign::try_new(
        id,
        platform,
        ad_type,
        destination,
        status,
        budget,
        spend,
        impressions,
        clicks,
        conversions,
        attributed_revenue,
    )
    .map_err(|_| ValidationError::MarketingInvariantFailed)
}

pub fn validate_click_attributed_campaign(
    campaign: MarketingCampaign,
) -> Result<ClickAttributedCampaign, ValidationError> {
    ClickAttributedCampaign::try_new(campaign)
        .map_err(|_| ValidationError::MarketingInvariantFailed)
}

pub fn validate_funnel(
    visitors: Nat,
    add_to_cart: Nat,
    checkout_started: Nat,
    purchases: Nat,
) -> Result<Funnel, ValidationError> {
    Funnel::try_new(visitors, add_to_cart, checkout_started, purchases)
        .map_err(|_| ValidationError::MarketingInvariantFailed)
}

pub fn validate_order_attribution_ledger(
    order: Order,
    credits: Vec<AttributionCredit>,
) -> Result<OrderAttributionLedger, ValidationError> {
    OrderAttributionLedger::try_new(order, credits)
        .map_err(|_| ValidationError::MarketingInvariantFailed)
}

pub fn validate_experiment_variant(
    id: Id,
    traffic_weight: Nat,
    visitors: Nat,
    conversions: Nat,
) -> Result<ExperimentVariant, ValidationError> {
    ExperimentVariant::try_new(id, traffic_weight, visitors, conversions)
        .map_err(|_| ValidationError::MarketingInvariantFailed)
}

pub fn validate_experiment(
    id: Id,
    variants: Vec<ExperimentVariant>,
) -> Result<Experiment, ValidationError> {
    Experiment::try_new(id, variants).map_err(|_| ValidationError::MarketingInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_trade_price_book_entry(
    sku: Sku,
    currency: Currency,
    unit_cost: Money,
    retail_unit_price: Money,
    wholesale_unit_price: Money,
    retail_margin: Money,
    wholesale_margin: Money,
    wholesale_min_qty: Quantity,
) -> Result<TradePriceBookEntry, ValidationError> {
    TradePriceBookEntry::try_new(
        sku,
        currency,
        unit_cost,
        retail_unit_price,
        wholesale_unit_price,
        retail_margin,
        wholesale_margin,
        wholesale_min_qty,
    )
    .map_err(|_| ValidationError::B2BInvariantFailed)
}

pub fn validate_retail_line(
    entry: TradePriceBookEntry,
    quantity: Quantity,
    discount: Money,
) -> Result<RetailLine, ValidationError> {
    RetailLine::try_new(entry, quantity, discount).map_err(|_| ValidationError::B2BInvariantFailed)
}

pub fn validate_wholesale_line(
    entry: TradePriceBookEntry,
    quantity: Quantity,
    discount: Money,
) -> Result<WholesaleLine, ValidationError> {
    WholesaleLine::try_new(entry, quantity, discount)
        .map_err(|_| ValidationError::B2BInvariantFailed)
}

pub fn validate_wholesale_credit_account(
    customer: Customer,
    credit_limit: Money,
    outstanding: Money,
) -> Result<WholesaleCreditAccount, ValidationError> {
    WholesaleCreditAccount::try_new(customer, credit_limit, outstanding)
        .map_err(|_| ValidationError::B2BInvariantFailed)
}

pub fn validate_supplier_daily_capacity(
    supplier: DropshipSupplier,
    daily_order_capacity: Nat,
    accepted_orders: Nat,
) -> Result<SupplierDailyCapacity, ValidationError> {
    SupplierDailyCapacity::try_new(supplier, daily_order_capacity, accepted_orders)
        .map_err(|_| ValidationError::DropshippingInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_dropship_offer(
    sku: Sku,
    supplier: DropshipSupplier,
    supplier_unit_cost: Money,
    sale_unit_price: Money,
    supplier_shipping_per_unit: Money,
    available_qty: Quantity,
    currency: Currency,
    active: bool,
) -> Result<DropshipOffer, ValidationError> {
    DropshipOffer::try_new(
        sku,
        supplier,
        supplier_unit_cost,
        sale_unit_price,
        supplier_shipping_per_unit,
        available_qty,
        currency,
        active,
    )
    .map_err(|_| ValidationError::DropshippingInvariantFailed)
}

pub fn validate_supplier_reservation(
    offer: DropshipOffer,
    supplier: DropshipSupplier,
    quantity: Quantity,
    status: SupplierReservationStatus,
) -> Result<SupplierReservation, ValidationError> {
    SupplierReservation::try_new(offer, supplier, quantity, status)
        .map_err(|_| ValidationError::DropshippingInvariantFailed)
}

pub fn validate_dropship_line(
    offer: DropshipOffer,
    quantity: Quantity,
    discount: Money,
) -> Result<DropshipLine, ValidationError> {
    DropshipLine::try_new(offer, quantity, discount)
        .map_err(|_| ValidationError::DropshippingInvariantFailed)
}

pub fn validate_reserved_dropship_line(
    line: DropshipLine,
    reservation: SupplierReservation,
) -> Result<ReservedDropshipLine, ValidationError> {
    ReservedDropshipLine::try_new(line, reservation)
        .map_err(|_| ValidationError::DropshippingInvariantFailed)
}

pub fn validate_dropship_purchase_order(
    supplier: DropshipSupplier,
    lines: Vec<DropshipLine>,
    quote: DropshipShippingQuote,
    status: DropshipPOStatus,
    total_supplier_cost: Money,
) -> Result<DropshipPurchaseOrder, ValidationError> {
    DropshipPurchaseOrder::try_new(supplier, lines, quote, status, total_supplier_cost)
        .map_err(|_| ValidationError::DropshippingInvariantFailed)
}

pub fn validate_dropship_fulfillment(
    customer_order: Order,
    purchase_order: DropshipPurchaseOrder,
    segment_revenue: Money,
) -> Result<DropshipFulfillment, ValidationError> {
    DropshipFulfillment::try_new(customer_order, purchase_order, segment_revenue)
        .map_err(|_| ValidationError::DropshippingInvariantFailed)
}

pub fn validate_dropship_return_request(
    line: DropshipLine,
    return_qty: Quantity,
    customer_refund: Money,
    supplier_credit: Money,
) -> Result<DropshipReturnRequest, ValidationError> {
    DropshipReturnRequest::try_new(line, return_qty, customer_refund, supplier_credit)
        .map_err(|_| ValidationError::DropshippingInvariantFailed)
}

pub fn validate_guaranteed_dropship_profit_quote(
    revenue: Money,
    costs: DropshipProfitCosts,
    min_profit: Money,
    profit: Money,
    signed_profit: SignedMoney,
) -> Result<GuaranteedDropshipProfitQuote, ValidationError> {
    GuaranteedDropshipProfitQuote::try_new(revenue, costs, min_profit, profit, signed_profit)
        .map_err(|_| ValidationError::ProfitInvariantFailed)
}

pub fn validate_dropship_cost_upper_bounds(
    actual: DropshipProfitCosts,
    upper: DropshipProfitCosts,
) -> Result<DropshipCostUpperBounds, ValidationError> {
    DropshipCostUpperBounds::try_new(actual, upper)
        .map_err(|_| ValidationError::ProfitInvariantFailed)
}

pub fn validate_singleton_competitor_price_benchmark(
    sku: Sku,
    currency: Currency,
    offer: CompetitorOffer,
) -> Result<CompetitorPriceBenchmark, ValidationError> {
    CompetitorPriceBenchmark::try_new(sku, currency, vec![offer.clone()], offer)
        .map_err(|_| ValidationError::CompetitorInvariantFailed)
}

pub fn validate_competitor_aware_dropship_offer(
    offer: DropshipOffer,
    benchmark: CompetitorPriceBenchmark,
    discount: Money,
    costs: DropshipProfitCosts,
    min_profit: Money,
) -> Result<CompetitorAwareDropshipOffer, ValidationError> {
    CompetitorAwareDropshipOffer::try_new(offer, benchmark, discount, costs, min_profit)
        .map_err(|_| ValidationError::CompetitorInvariantFailed)
}

pub fn validate_brand_pricing_policy(
    map_price: Money,
    msrp: Money,
) -> Result<BrandPricingPolicy, ValidationError> {
    BrandPricingPolicy::try_new(map_price, msrp)
        .map_err(|_| ValidationError::MerchandisingInvariantFailed)
}

pub fn validate_bundle_component(
    sku: Sku,
    units_per_bundle: Quantity,
    stock_available: Quantity,
) -> Result<BundleComponent, ValidationError> {
    BundleComponent::try_new(sku, units_per_bundle, stock_available)
        .map_err(|_| ValidationError::MerchandisingInvariantFailed)
}

pub fn bundle_components_can_fulfill_all(
    bundle_qty: Quantity,
    components: &[BundleComponent],
) -> DomainResult<bool> {
    for component in components {
        if !component_can_fulfill_bundles(bundle_qty, component)? {
            return Ok(false);
        }
    }
    Ok(true)
}

pub fn validate_bundle_reservation(
    bundle_qty: Quantity,
    components: Vec<BundleComponent>,
) -> Result<BundleReservation, ValidationError> {
    if !bundle_components_can_fulfill_all(bundle_qty, &components)
        .map_err(|_| ValidationError::MerchandisingInvariantFailed)?
    {
        return Err(ValidationError::MerchandisingInvariantFailed);
    }
    BundleReservation::try_new(bundle_qty, components)
        .map_err(|_| ValidationError::MerchandisingInvariantFailed)
}

pub fn validate_accepted_promotion_set(
    resulting_price: Money,
    total_discount: Money,
    discount_cap: Money,
    profit_floor: Money,
) -> Result<AcceptedPromotionSet, ValidationError> {
    AcceptedPromotionSet::try_new(resulting_price, total_discount, discount_cap, profit_floor)
        .map_err(|_| ValidationError::MerchandisingInvariantFailed)
}

pub fn validate_search_result_item(
    item: SearchResultItem,
) -> Result<ValidSearchResultItem, ValidationError> {
    ValidSearchResultItem::try_new(item).map_err(|_| ValidationError::MerchandisingInvariantFailed)
}

pub fn validate_exchange_rate(
    source: Currency,
    target: Currency,
    numerator: Nat,
    denominator: Nat,
    observed_at: Timestamp,
) -> Result<ExchangeRate, ValidationError> {
    ExchangeRate::try_new(source, target, numerator, denominator, observed_at)
        .map_err(|_| ValidationError::FinanceInvariantFailed)
}

pub fn validate_tax_calculation(
    taxable_amount: Money,
    rate: TaxRate,
    rounding_mode: RoundingMode,
    tax: Money,
    total: Money,
) -> Result<TaxCalculation, ValidationError> {
    TaxCalculation::try_new(taxable_amount, rate, rounding_mode, tax, total)
        .map_err(|_| ValidationError::FinanceInvariantFailed)
}

pub fn validate_tax_inclusive_price(
    gross: Money,
    net: Money,
    tax: Money,
) -> Result<TaxInclusivePrice, ValidationError> {
    TaxInclusivePrice::try_new(gross, net, tax).map_err(|_| ValidationError::TaxInvariantFailed)
}

pub fn validate_tax_exclusive_price(
    net: Money,
    tax: Money,
    total: Money,
) -> Result<TaxExclusivePrice, ValidationError> {
    TaxExclusivePrice::try_new(net, tax, total).map_err(|_| ValidationError::TaxInvariantFailed)
}

#[derive(Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawTaxInvoiceLine {
    pub sku: Sku,
    pub quantity: Quantity,
    pub unit_price: Money,
    pub discount: Money,
    pub treatment: TaxTreatment,
    pub rate: TaxRate,
    pub rounding_mode: RoundingMode,
    pub taxable_amount: Money,
    pub tax: Money,
    pub total: Money,
}

pub fn validate_tax_invoice_line(
    raw: RawTaxInvoiceLine,
) -> Result<TaxInvoiceLine, ValidationError> {
    TaxInvoiceLine::try_new(
        raw.sku,
        raw.quantity,
        raw.unit_price,
        raw.discount,
        raw.treatment,
        raw.rate,
        raw.rounding_mode,
        raw.taxable_amount,
        raw.tax,
        raw.total,
    )
    .map_err(|_| ValidationError::TaxInvariantFailed)
}

pub fn validate_tax_invoice_lines(
    raw: Vec<RawTaxInvoiceLine>,
) -> Result<Vec<TaxInvoiceLine>, ValidationError> {
    raw.into_iter().map(validate_tax_invoice_line).collect()
}

#[derive(Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawTaxInvoice {
    pub id: Id,
    pub issued_at: Timestamp,
    pub seller_id: Id,
    pub buyer_id: CustomerId,
    pub jurisdiction: TaxJurisdiction,
    pub currency: Currency,
    pub lines: Vec<RawTaxInvoiceLine>,
    pub subtotal: Money,
    pub tax: Money,
    pub shipping: Money,
    pub discount: Money,
    pub total: Money,
}

pub fn validate_tax_invoice(raw: RawTaxInvoice) -> Result<TaxInvoice, ValidationError> {
    let lines = validate_tax_invoice_lines(raw.lines)?;
    TaxInvoice::try_new(
        raw.id,
        raw.issued_at,
        raw.seller_id,
        raw.buyer_id,
        raw.jurisdiction,
        raw.currency,
        lines,
        raw.subtotal,
        raw.tax,
        raw.shipping,
        raw.discount,
        raw.total,
    )
    .map_err(|_| ValidationError::TaxInvariantFailed)
}

pub fn validate_order_tax_invoice_link(
    order: Order,
    invoice: TaxInvoice,
) -> Result<OrderTaxInvoiceLink, ValidationError> {
    OrderTaxInvoiceLink::try_new(order, invoice).map_err(|_| ValidationError::TaxInvariantFailed)
}

pub fn validate_tax_exemption_certificate(
    customer_id: CustomerId,
    jurisdiction_id: Id,
    valid_from: Timestamp,
    valid_until: Timestamp,
) -> Result<TaxExemptionCertificate, ValidationError> {
    TaxExemptionCertificate::try_new(customer_id, jurisdiction_id, valid_from, valid_until)
        .map_err(|_| ValidationError::TaxInvariantFailed)
}

pub fn validate_b2b_tax_exemption(
    customer: Customer,
    jurisdiction: TaxJurisdiction,
    certificate: TaxExemptionCertificate,
    checked_at: Timestamp,
) -> Result<B2BTaxExemption, ValidationError> {
    B2BTaxExemption::try_new(customer, jurisdiction, certificate, checked_at)
        .map_err(|_| ValidationError::TaxInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_marketplace_facilitator_tax(
    marketplace: Marketplace,
    jurisdiction: TaxJurisdiction,
    taxable_amount: Money,
    rate: TaxRate,
    rounding_mode: RoundingMode,
    tax: Money,
    facilitator_collects: bool,
    seller_tax_due: Money,
) -> Result<MarketplaceFacilitatorTax, ValidationError> {
    MarketplaceFacilitatorTax::try_new(
        marketplace,
        jurisdiction,
        taxable_amount,
        rate,
        rounding_mode,
        tax,
        facilitator_collects,
        seller_tax_due,
    )
    .map_err(|_| ValidationError::TaxInvariantFailed)
}

pub fn validate_carrier_quote(
    service: CarrierService,
    package: Package,
    price: Money,
) -> Result<CarrierQuote, ValidationError> {
    CarrierQuote::try_new(service, package, price)
        .map_err(|_| ValidationError::FinanceInvariantFailed)
}

pub fn validate_reconciliation_within_tolerance(
    expected: Money,
    actual: Money,
    tolerance: Money,
) -> Result<ReconciliationWithinTolerance, ValidationError> {
    ReconciliationWithinTolerance::try_new(expected, actual, tolerance)
        .map_err(|_| ValidationError::FinanceInvariantFailed)
}

pub fn validate_subscription_plan(
    price: Money,
    period_days: Days,
) -> Result<SubscriptionPlan, ValidationError> {
    SubscriptionPlan::try_new(price, period_days)
        .map_err(|_| ValidationError::PostPurchaseInvariantFailed)
}

pub fn validate_recurring_subscription(
    customer: CustomerId,
    plan: SubscriptionPlan,
    status: SubscriptionLifecycleStatus,
    current_billing_date: Timestamp,
    next_billing_date: Timestamp,
) -> Result<RecurringSubscription, ValidationError> {
    RecurringSubscription::try_new(
        customer,
        plan,
        status,
        current_billing_date,
        next_billing_date,
    )
    .map_err(|_| ValidationError::PostPurchaseInvariantFailed)
}

pub fn validate_gift_card_redemption(
    card: GiftCard,
    amount: Money,
) -> Result<GiftCardRedemption, ValidationError> {
    GiftCardRedemption::try_new(card, amount)
        .map_err(|_| ValidationError::PostPurchaseInvariantFailed)
}

pub fn validate_chargeback(
    payment_amount: Money,
    chargeback_amount: Money,
) -> Result<Chargeback, ValidationError> {
    Chargeback::try_new(payment_amount, chargeback_amount)
        .map_err(|_| ValidationError::PostPurchaseInvariantFailed)
}

pub fn validate_cashflow_plan(
    starting_cash: Money,
    required_reserve: Money,
    expected_inflows: Money,
    expected_outflows: Money,
) -> Result<CashflowPlan, ValidationError> {
    CashflowPlan::try_new(
        starting_cash,
        required_reserve,
        expected_inflows,
        expected_outflows,
    )
    .map_err(|_| ValidationError::PostPurchaseInvariantFailed)
}

pub fn validate_event_backed_cashflow_plan(
    starting_cash: Money,
    required_reserve: Money,
    events: Vec<CashflowEvent>,
) -> Result<EventBackedCashflowPlan, ValidationError> {
    EventBackedCashflowPlan::try_new(starting_cash, required_reserve, events)
        .map_err(|_| ValidationError::PostPurchaseInvariantFailed)
}

pub fn validate_audited_command(
    actor: Role,
    action: Action,
    order_id: OrderId,
    event: AuditEvent,
) -> Result<AuditedCommand, ValidationError> {
    AuditedCommand::try_new(actor, action, order_id, event)
        .map_err(|_| ValidationError::AuditPermissionDenied)
}

pub fn validate_audited_entity_command(
    actor: Role,
    action: Action,
    subject_id: Id,
    event: EntityAuditEvent,
) -> Result<AuditedEntityCommand, ValidationError> {
    AuditedEntityCommand::try_new(actor, action, subject_id, event)
        .map_err(|_| ValidationError::AuditPermissionDenied)
}

pub fn validate_event_stream(stream: EventStream) -> Result<ValidEventStream, ValidationError> {
    ValidEventStream::try_new(stream).map_err(|_| ValidationError::EventStreamInvalid)
}

pub fn validate_approved_supplier_quality(
    supplier: DropshipSupplier,
    metrics: SupplierQualityMetrics,
    policy: SupplierRiskPolicy,
) -> Result<ApprovedSupplierQuality, ValidationError> {
    ApprovedSupplierQuality::try_new(supplier, metrics, policy)
        .map_err(|_| ValidationError::SupplierQualityInvalid)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_dropship_opportunity_candidate(
    sku: Sku,
    units: Quantity,
    target_price: Money,
    required_capital: Money,
    expected_profit: Money,
    min_profit: Money,
    competitor_price: Money,
    costs: DropshipProfitCosts,
) -> Result<DropshipOpportunityCandidate, ValidationError> {
    DropshipOpportunityCandidate::try_new(
        sku,
        units,
        target_price,
        required_capital,
        expected_profit,
        min_profit,
        competitor_price,
        costs,
    )
    .map_err(|_| ValidationError::OpportunityInvariantFailed)
}

pub fn validate_dropship_opportunity_portfolio(
    selected: Vec<DropshipOpportunityCandidate>,
    investment_fund: Money,
) -> Result<DropshipOpportunityPortfolio, ValidationError> {
    DropshipOpportunityPortfolio::try_new(selected, investment_fund)
        .map_err(|_| ValidationError::OpportunityInvariantFailed)
}

pub fn validate_crm_account(
    id: AccountId,
    customer: Customer,
    tier: AccountTier,
    status: CRMAccountStatus,
    lifetime_value: Money,
    open_balance: Money,
) -> Result<CRMAccount, ValidationError> {
    CRMAccount::try_new(id, customer, tier, status, lifetime_value, open_balance)
        .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_active_crm_account(
    account: CRMAccount,
) -> Result<ActiveCRMAccount, ValidationError> {
    ActiveCRMAccount::try_new(account).map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_crm_account_contact(
    account: CRMAccount,
    contact: CRMContact,
) -> Result<CRMAccountContact, ValidationError> {
    CRMAccountContact::try_new(account, contact).map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_permitted_customer_message(
    interaction_id: InteractionId,
    contact: CRMContact,
    sent_at: Timestamp,
) -> Result<PermittedCustomerMessage, ValidationError> {
    PermittedCustomerMessage::try_new(interaction_id, contact, sent_at)
        .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_permitted_account_message(
    account_contact: CRMAccountContact,
    message: PermittedCustomerMessage,
) -> Result<PermittedAccountMessage, ValidationError> {
    PermittedAccountMessage::try_new(account_contact, message)
        .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_crm_interaction(
    id: InteractionId,
    account_id: AccountId,
    contact_id: ContactId,
    kind: InteractionKind,
    occurred_at: Timestamp,
    follow_up_due_at: Timestamp,
) -> Result<CRMInteraction, ValidationError> {
    CRMInteraction::try_new(
        id,
        account_id,
        contact_id,
        kind,
        occurred_at,
        follow_up_due_at,
    )
    .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_crm_interaction_for_contact(
    account_contact: CRMAccountContact,
    interaction: CRMInteraction,
) -> Result<CRMInteractionForContact, ValidationError> {
    CRMInteractionForContact::try_new(account_contact, interaction)
        .map_err(|_| ValidationError::CrmInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_lead(
    id: LeadId,
    account_id: AccountId,
    contact_id: ContactId,
    source_campaign: Option<CampaignId>,
    status: LeadStatus,
    estimated_value: Money,
    currency: Currency,
    created_at: Timestamp,
    updated_at: Timestamp,
) -> Result<Lead, ValidationError> {
    Lead::try_new(
        id,
        account_id,
        contact_id,
        source_campaign,
        status,
        estimated_value,
        currency,
        created_at,
        updated_at,
    )
    .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_lead_for_contact(
    account_contact: CRMAccountContact,
    lead: Lead,
) -> Result<LeadForContact, ValidationError> {
    LeadForContact::try_new(account_contact, lead).map_err(|_| ValidationError::CrmInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_sales_opportunity(
    id: OpportunityId,
    account_id: AccountId,
    contact_id: ContactId,
    source_lead: Option<LeadId>,
    stage: OpportunityStage,
    amount: Money,
    currency: Currency,
    probability: BasisPoints,
    opened_at: Timestamp,
    updated_at: Timestamp,
    expected_close_at: Timestamp,
) -> Result<SalesOpportunity, ValidationError> {
    SalesOpportunity::try_new(
        id,
        account_id,
        contact_id,
        source_lead,
        stage,
        amount,
        currency,
        probability,
        opened_at,
        updated_at,
        expected_close_at,
    )
    .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_opportunity_for_contact(
    account_contact: CRMAccountContact,
    opportunity: SalesOpportunity,
) -> Result<OpportunityForContact, ValidationError> {
    OpportunityForContact::try_new(account_contact, opportunity)
        .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_sales_pipeline(
    currency: Currency,
    opportunities: Vec<SalesOpportunity>,
) -> Result<SalesPipeline, ValidationError> {
    SalesPipeline::try_new(currency, opportunities).map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_customer_segment(
    id: SegmentId,
    name: String,
    member_count: Nat,
    min_lifetime_value: Money,
    max_retention_discount: Money,
) -> Result<CustomerSegment, ValidationError> {
    CustomerSegment::try_new(
        id,
        name,
        member_count,
        min_lifetime_value,
        max_retention_discount,
    )
    .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_segment_membership(
    account: CRMAccount,
    segment: CustomerSegment,
) -> Result<SegmentMembership, ValidationError> {
    SegmentMembership::try_new(account, segment).map_err(|_| ValidationError::CrmInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_support_case(
    id: SupportCaseId,
    account_id: AccountId,
    contact_id: ContactId,
    order_id: Option<OrderId>,
    status: SupportCaseStatus,
    priority: SupportPriority,
    opened_at: Timestamp,
    last_updated_at: Timestamp,
    sla_due_at: Timestamp,
) -> Result<SupportCase, ValidationError> {
    SupportCase::try_new(
        id,
        account_id,
        contact_id,
        order_id,
        status,
        priority,
        opened_at,
        last_updated_at,
        sla_due_at,
    )
    .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_support_case_for_contact(
    account_contact: CRMAccountContact,
    case_: SupportCase,
) -> Result<SupportCaseForContact, ValidationError> {
    SupportCaseForContact::try_new(account_contact, case_)
        .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_resolved_support_case(
    case_: SupportCase,
    resolved_at: Timestamp,
) -> Result<ResolvedSupportCase, ValidationError> {
    ResolvedSupportCase::try_new(case_, resolved_at)
        .map_err(|_| ValidationError::CrmInvariantFailed)
}

pub fn validate_retention_offer(
    account: CRMAccount,
    segment: CustomerSegment,
    coupon: Coupon,
    uses_before: Nat,
    discount: Money,
) -> Result<RetentionOffer, ValidationError> {
    RetentionOffer::try_new(account, segment, coupon, uses_before, discount)
        .map_err(|_| ValidationError::CrmInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_logistics_shipment_plan(
    id: ShipmentId,
    order: Order,
    fulfillment: DistinctFulfillmentPlan,
    quote: CarrierQuote,
    warehouse: Warehouse,
    destination: ShippingDestination,
    planned_ship_at: Timestamp,
    promised_delivery_at: Timestamp,
) -> Result<LogisticsShipmentPlan, ValidationError> {
    let package = quote.package().clone();
    LogisticsShipmentPlan::try_new(
        id,
        order,
        fulfillment,
        package,
        quote,
        warehouse,
        destination,
        planned_ship_at,
        promised_delivery_at,
    )
    .map_err(|_| ValidationError::LogisticsInvariantFailed)
}

pub fn validate_logistics_shipment(
    id: ShipmentId,
    plan: LogisticsShipmentPlan,
    status: ShipmentStatus,
    created_at: Timestamp,
    updated_at: Timestamp,
) -> Result<LogisticsShipment, ValidationError> {
    LogisticsShipment::try_new(id, plan, status, created_at, updated_at)
        .map_err(|_| ValidationError::LogisticsInvariantFailed)
}

pub fn validate_carrier_handoff(
    plan: LogisticsShipmentPlan,
    tracking_number: Id,
    handed_off_at: Timestamp,
    acceptance_scan_at: Timestamp,
) -> Result<CarrierHandoff, ValidationError> {
    let service = plan.quote().service().clone();
    CarrierHandoff::try_new(
        plan,
        service,
        tracking_number,
        handed_off_at,
        acceptance_scan_at,
    )
    .map_err(|_| ValidationError::LogisticsInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_warehouse_transfer(
    id: TransferId,
    sku: Sku,
    from_warehouse: Warehouse,
    to_warehouse: Warehouse,
    source_stock: StockState,
    requested: Quantity,
    in_transit: Quantity,
    received: Quantity,
) -> Result<WarehouseTransfer, ValidationError> {
    WarehouseTransfer::try_new(
        id,
        sku,
        from_warehouse,
        to_warehouse,
        source_stock,
        requested,
        in_transit,
        received,
    )
    .map_err(|_| ValidationError::LogisticsInvariantFailed)
}

#[allow(clippy::too_many_arguments)]
pub fn validate_return_authorization(
    id: ReturnAuthorizationId,
    support_case: SupportCase,
    order: Order,
    ledger: PaymentLedger,
    status: ReturnAuthorizationStatus,
    lines: Vec<ReturnLine>,
    quantity: Quantity,
    refund_amount: Money,
    requested_at: Timestamp,
    decided_at: Timestamp,
) -> Result<ReturnAuthorization, ValidationError> {
    ReturnAuthorization::try_new(
        id,
        support_case,
        order,
        ledger,
        status,
        lines,
        quantity,
        refund_amount,
        requested_at,
        decided_at,
    )
    .map_err(|_| ValidationError::LogisticsInvariantFailed)
}

pub fn validate_return_receipt(
    authorization: ReturnAuthorization,
    received_quantity: Quantity,
    refund_issued: Money,
    received_at: Timestamp,
) -> Result<ReturnReceipt, ValidationError> {
    ReturnReceipt::try_new(authorization, received_quantity, refund_issued, received_at)
        .map_err(|_| ValidationError::LogisticsInvariantFailed)
}

pub fn validate_bounded_coupon_application(
    coupon: Coupon,
    subtotal: Money,
    uses_before: Nat,
) -> Result<BoundedCouponApplication, ValidationError> {
    BoundedCouponApplication::try_new(coupon, subtotal, uses_before)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_captured_payment_matches_order(
    order: Order,
    payment: CapturedPayment,
) -> Result<CapturedPaymentMatchesOrder, ValidationError> {
    CapturedPaymentMatchesOrder::try_new(order, payment)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_sellable_catalog_entry(
    entry: ProductCatalogEntry,
) -> Result<SellableCatalogEntry, ValidationError> {
    SellableCatalogEntry::try_new(entry).map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_publishable_feed_line(
    line: SafeProductFeedLine,
) -> Result<PublishableFeedLine, ValidationError> {
    PublishableFeedLine::try_new(line).map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_sourceable_distributor_product(
    product: DistributorProduct,
    units: Quantity,
) -> Result<SourceableDistributorProduct, ValidationError> {
    SourceableDistributorProduct::try_new(product, units)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_fraud_checked_coupon_application(
    application: BoundedCouponApplication,
    policy: FraudPolicy,
) -> Result<FraudCheckedCouponApplication, ValidationError> {
    FraudCheckedCouponApplication::try_new(application, policy)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_captured_payment_journal_projection(
    accounts: AccountingAccounts,
    payment: CapturedPayment,
) -> Result<CapturedPaymentJournalProjection, ValidationError> {
    let journal = payment_captured_journal(&accounts, payment.amount())
        .map_err(|_| ValidationError::ImplicitInvariantFailed)?;
    CapturedPaymentJournalProjection::try_new(accounts, payment, journal)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_refund_journal_projection(
    accounts: AccountingAccounts,
    ledger: PaymentLedger,
    amount: Money,
) -> Result<RefundJournalProjection, ValidationError> {
    let journal = refund_issued_journal(&accounts, amount)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)?;
    RefundJournalProjection::try_new(accounts, ledger, amount, journal)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_advertisable_synced_marketplace_listing(
    synced: SyncedMarketplaceListing,
) -> Result<AdvertisableSyncedMarketplaceListing, ValidationError> {
    AdvertisableSyncedMarketplaceListing::try_new(synced)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_wholesale_credit_checkout(
    account: WholesaleCreditAccount,
    lines: Vec<WholesaleLine>,
    terms: PaymentTerms,
    order_total: Money,
) -> Result<WholesaleCreditCheckout, ValidationError> {
    WholesaleCreditCheckout::try_new(account, lines, terms, order_total)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_trusted_fresh_competitor_benchmark(
    benchmark: CompetitorPriceBenchmark,
    now: Timestamp,
    max_age: Duration,
    trust: TrustLevel,
) -> Result<TrustedFreshCompetitorBenchmark, ValidationError> {
    TrustedFreshCompetitorBenchmark::try_new(benchmark, now, max_age, trust)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_map_compliant_competitor_aware_offer(
    offer: CompetitorAwareDropshipOffer,
    policy: BrandPricingPolicy,
) -> Result<MapCompliantCompetitorAwareOffer, ValidationError> {
    MapCompliantCompetitorAwareOffer::try_new(offer, policy)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_fresh_currency_conversion(
    source_amount: MoneyAmount,
    rate: ExchangeRate,
    target_amount: MoneyAmount,
    now: Timestamp,
    max_age: Duration,
) -> Result<FreshCurrencyConversion, ValidationError> {
    FreshCurrencyConversion::try_new(source_amount, rate, target_amount, now, max_age)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_valid_gift_card_redemption_at(
    now: Timestamp,
    redemption: GiftCardRedemption,
) -> Result<ValidGiftCardRedemptionAt, ValidationError> {
    ValidGiftCardRedemptionAt::try_new(now, redemption)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_chargeback_for_captured_payment(
    payment: CapturedPayment,
    chargeback: Chargeback,
) -> Result<ChargebackForCapturedPayment, ValidationError> {
    ChargebackForCapturedPayment::try_new(payment, chargeback)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_actionable_demand_forecast(
    forecast: DemandForecast,
) -> Result<ActionableDemandForecast, ValidationError> {
    ActionableDemandForecast::try_new(forecast)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_approved_orderable_supplier_quality(
    quality: ApprovedSupplierQuality,
) -> Result<ApprovedOrderableSupplierQuality, ValidationError> {
    ApprovedOrderableSupplierQuality::try_new(quality)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_converted_lead_opportunity(
    lead: Lead,
    opportunity: SalesOpportunity,
) -> Result<ConvertedLeadOpportunity, ValidationError> {
    ConvertedLeadOpportunity::try_new(lead, opportunity)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_crm_order_contact(
    account: CRMAccount,
    contact: CRMContact,
    order: Order,
) -> Result<CRMOrderContact, ValidationError> {
    CRMOrderContact::try_new(account, contact, order)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_shipment_for_crm_order(
    crm_order: CRMOrderContact,
    plan: LogisticsShipmentPlan,
) -> Result<ShipmentForCRMOrder, ValidationError> {
    ShipmentForCRMOrder::try_new(crm_order, plan)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_logistics_exception_support_case(
    exception: LogisticsException,
    shipment: LogisticsShipmentPlan,
    support_case: SupportCase,
) -> Result<LogisticsExceptionSupportCase, ValidationError> {
    LogisticsExceptionSupportCase::try_new(exception, shipment, support_case)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}

pub fn validate_crm_approved_return_handling(
    authorization: ReturnAuthorization,
    receipt: ReturnReceipt,
) -> Result<CRMApprovedReturnHandling, ValidationError> {
    CRMApprovedReturnHandling::try_new(authorization, receipt)
        .map_err(|_| ValidationError::ImplicitInvariantFailed)
}