🥮 mooncakes.io

    moonbit-freight-calculator

    A MoonBit freight billing rule engine for parcel logistics.

    freight
    billing
    logistics
    tariff
    calculator
    Download zip
    Author
    Version
    0.3.0
    License
    MIT
    Repository
    Last updated
    2 months ago
    Downloads
    27

    No dependencies

    #moonbit-freight-calculator

    Typed, deterministic freight-rating primitives for MoonBit applications. The library turns parcel dimensions, weight, route, tariff bands, and surcharges into an auditable quote made of exact integer-cent charge lines.

    #Positioning and users

    This is an embeddable freight-rating component for logistics platforms, carrier integrations, warehouse tools, and MoonBit application developers who need deterministic parcel quotes. MoonBit is a good fit here because the domain model is strongly typed, money is represented as exact integer cents, and the same checked code is validated across wasm, wasm-gc, JavaScript, and native targets.

    #Core capabilities

    • Actual-versus-dimensional weight using configurable divisors.
    • First-weight and incremental-weight ladder pricing.
    • Zone multipliers, remote-area fees, overweight and oversize surcharges.
    • Fuel and declared-value insurance charges with minimum-charge protection.
    • Exact Money arithmetic, configurable rounding, discount stacks, and tax basis calculation.
    • Route selection, service metadata, manifest totals, and weight outlier analysis.
    • Tariff candidate composition with applicability predicates and decision traces.
    • Settlement invoices, payment allocation, balance states, and manifest reconciliation.
    • Business-calendar SLA deadlines, customs duty summaries, bulk-job state transitions, manifest validation, audit chains, and service promises.
    • Built-in domestic, regional, international, and returns weight-band catalogs.
    • CLI demo and a deterministic benchmark with a checksum.

    #Quick start

    moon check --target all
moon test --target all
moon run cmd/main

    ///|
    test {
      let rule = standard_rule()
      let parcel = parcel_dim(width_cm=42, height_cm=30, depth_cm=24, weight_g=2600)
      let result = quote(rule, parcel, "regional", Money::yuan(300))
      inspect(result.summary(), content="billable=5040g total=CNY 61.03 lines=5")
    }

    #CLI

    The example CLI quotes the checked-in sample manifest:

    moon run cmd/main

    It prints one manifest total followed by an auditable summary for each parcel. The library itself is pure and can be embedded without the CLI package.

    #Architecture

    types.mbt                 public domain types
money*.mbt                exact money and rounding operations
parcel*.mbt               dimensional weight and parcel profiling
rules.mbt / audit*.mbt    tariff construction and validation
engine.mbt                quote and manifest calculation
discounts.mbt / taxes.mbt adjustments and tax basis
routing.mbt               origin/destination lane resolution
catalog*.mbt              operational weight-band tables
manifest_analytics.mbt    manifest-level operational metrics
tariff_composition.mbt    candidate selection and decision traces
settlement_*.mbt          invoice, payment, and reconciliation workflows
sla_calendar.mbt          business-day and service-window deadlines
customs_engine.mbt        duty, insurance, and declared-value totals
bulk_pipeline.mbt         deterministic bulk-job transitions
route_planner.mbt         capacity-aware shortest-path planning
manifest_validation.mbt  duplicate, value, weight, and zone checks
audit_chain.mbt           tamper-evident event history
service_promise.mbt       delivery promise and breach classification
cmd/main                  runnable example
benchmarks                deterministic performance smoke benchmark

    Public concrete types live in the root package. Files are organizational units; package boundaries are defined by moon.pkg.

    #Benchmark

    Run the real quote engine over the checked-in manifest 1,000 times:

    moon run benchmarks

    The reproducible checksum is items=3000 total=CNY 269930.00. On the validation host (Windows, MoonBit 0.1.20260819, moonc v0.10.9+6e6c44045, wasm-gc target), three command runs were 194.29 ms, 177.00 ms, and 163.36 ms; the median was 177.00 ms for 3,000 quote operations, or approximately 16,949 operations per second. Wall-clock results are host-dependent; see docs/benchmarks.md.

    #Testing and CI

    Local validation:

    moon fmt --check
moon check --deny-warn --target all
moon info
moon test --deny-warn --target all
moon test --deny-warn --target native --enable-coverage
moon coverage report -f summary

    GitHub Actions runs the same quality gates on Ubuntu, macOS, and Windows. It pins the stable MoonBit toolchain to v0.10.9+6e6c44045, checks all backends, verifies formatting and generated interfaces, runs tests with coverage, and executes the native test target.

    #License

    MIT. See LICENSE.

    #Maintenance

    Public behavior is covered by executable tests and the generated interface is checked into the repository. Changes are recorded in CHANGELOG.md and released through the Mooncakes package identified in moon.mod.

    AgingBand

    source
    pub(all) enum AgingBand {
      Current
      Days1To7
      Days8To30
      Days31To60
      Over60
    } derive(Eq, ToJson, 
    Debug    )

    AgingBucket

    source
    pub struct AgingBucket {
      band : AgingBand
      amount : Money
    } derive(Eq, ToJson, 
    Debug    )

    AgingBucket::band_name

    source
    fn AgingBucket::band_name(self : AgingBucket) -> String

    AgingBucket::is_empty

    source
    fn AgingBucket::is_empty(self : AgingBucket) -> Bool

    AuditChain

    source
    pub struct AuditChain {
      events : Array[AuditEvent]
      digest : Int
    } derive(Eq, ToJson, 
    Debug    )

    AuditChain::is_monotonic

    source
    fn AuditChain::is_monotonic(self : AuditChain) -> Bool

    AuditChain::last_sequence

    source
    fn AuditChain::last_sequence(self : AuditChain) -> Int

    AuditChain::length

    source
    fn AuditChain::length(self : AuditChain) -> Int

    AuditEvent

    source
    pub struct AuditEvent {
      sequence : Int
      code : String
      detail : String
      amount : Money
    } derive(Eq, ToJson, 
    Debug    )

    BalanceState

    source
    pub(all) enum BalanceState {
      Unpaid
      PartiallyPaid
      Paid
      Overpaid
    } derive(Eq, ToJson, 
    Debug    )

    BalanceState::is_terminal

    source
    fn BalanceState::is_terminal(self : BalanceState) -> Bool

    BillingRule

    source
    pub struct BillingRule {
      volumetric_divisor : Int
      first_weight_limit_g : Int
      first_weight_rate : Money
      additional_weight_unit_g : Int
      additional_weight_rate : Money
      min_charge : Money
      zones : Array[ZoneRate]
      surcharge : SurchargePolicy
    } derive(Eq, ToJson, 
    Debug    )

    BillingRule::zone_rate

    source
    fn BillingRule::zone_rate(self : BillingRule, zone : String) -> ZoneRate

    BulkJob

    source
    pub struct BulkJob {
      id : String
      state : JobState
      item_count : Int
      completed : Int
      failed : Int
      attempts : Int
    } derive(Eq, ToJson, 
    Debug    )

    BulkJob::is_terminal

    source
    fn BulkJob::is_terminal(self : BulkJob) -> Bool

    BulkJob::progress_bp

    source
    fn BulkJob::progress_bp(self : BulkJob) -> Int

    BulkJob::remaining

    source
    fn BulkJob::remaining(self : BulkJob) -> Int

    BusinessCalendar

    source
    pub struct BusinessCalendar {
      weekend_days : Array[Int]
      holidays : Array[Int]
      cutoff_hour : Int
    } derive(Eq, ToJson, 
    Debug    )

    BusinessCalendar::holiday_count

    source
    fn BusinessCalendar::holiday_count(self : BusinessCalendar) -> Int

    BusinessCalendar::is_valid

    source
    fn BusinessCalendar::is_valid(self : BusinessCalendar) -> Bool

    BusinessCalendar::weekend_count

    source
    fn BusinessCalendar::weekend_count(self : BusinessCalendar) -> Int

    BusinessCalendar::working_days_between

    source
    fn BusinessCalendar::working_days_between(self : BusinessCalendar, start_day : Int, end_day : Int) -> Int

    ChargeLine

    source
    pub enum ChargeLine {
      Base(weight_g~ : Int, Money)
      Additional(units~ : Int, Money)
      Zone(zone~ : String, multiplier_bp~ : Int, Money)
      Remote(zone~ : String, Money)
      Overweight(limit_g~ : Int, Money)
      Oversize(limit_cm~ : Int, Money)
      Fuel(percent_bp~ : Int, Money)
      Insurance(percent_bp~ : Int, declared_value~ : Money, Money)
      Minimum(Money)
    } derive(Eq, ToJson, 
    Debug    )

    ConfigDiagnostic

    source
    pub struct ConfigDiagnostic {
      code : String
      severity : DiagnosticSeverity
      field : String
      message : String
    } derive(Eq, ToJson, 
    Debug    )

    ConfigDiagnostic::is_blocking

    source
    fn ConfigDiagnostic::is_blocking(self : ConfigDiagnostic) -> Bool

    ConfigDiagnostic::summary

    source
    fn ConfigDiagnostic::summary(self : ConfigDiagnostic) -> String

    CustomsAssessment

    source
    pub struct CustomsAssessment {
      decision : CustomsDecision
      duty : Money
      reasons : Array[String]
    } derive(Eq, ToJson, 
    Debug    )

    CustomsAssessment::is_clear

    source
    fn CustomsAssessment::is_clear(self : CustomsAssessment) -> Bool

    CustomsAssessment::is_rejected

    source
    fn CustomsAssessment::is_rejected(self : CustomsAssessment) -> Bool

    CustomsAssessment::reason_count

    source
    fn CustomsAssessment::reason_count(self : CustomsAssessment) -> Int

    CustomsAssessment::requires_review

    source
    fn CustomsAssessment::requires_review(self : CustomsAssessment) -> Bool

    CustomsDecision

    source
    pub(all) enum CustomsDecision {
      Clear
      Review
      Reject
    } derive(Eq, ToJson, 
    Debug    )

    CustomsDocument

    source
    pub struct CustomsDocument {
      hs_code : String
      description : String
      declared_value : Money
      origin : String
      restricted : Bool
    } derive(Eq, ToJson, 
    Debug    )

    CustomsLine

    source
    pub struct CustomsLine {
      code : String
      declared_value : Money
      duty_bp : Int
      insurance_bp : Int
    } derive(Eq, ToJson, 
    Debug    )

    CustomsLine::is_valid

    source
    fn CustomsLine::is_valid(self : CustomsLine) -> Bool

    CustomsSummary

    source
    pub struct CustomsSummary {
      declared_value : Money
      duty : Money
      insurance : Money
      total : Money
    } derive(Eq, ToJson, 
    Debug    )

    CustomsSummary::effective_duty_bp

    source
    fn CustomsSummary::effective_duty_bp(self : CustomsSummary) -> Int

    CustomsSummary::is_empty

    source
    fn CustomsSummary::is_empty(self : CustomsSummary) -> Bool

    DecisionTrace

    source
    pub struct DecisionTrace {
      selected : String
      considered : Int
      rejected : Array[String]
      reasons : Array[String]
    } derive(Eq, ToJson, 
    Debug    )

    DecisionTrace::explanation

    source
    fn DecisionTrace::explanation(self : DecisionTrace) -> String

    DecisionTrace::has_selection

    source
    fn DecisionTrace::has_selection(self : DecisionTrace) -> Bool

    DecisionTrace::rejection_count

    source
    fn DecisionTrace::rejection_count(self : DecisionTrace) -> Int

    DiagnosticSeverity

    source
    pub enum DiagnosticSeverity {
      Info
      Warning
      Error
    } derive(Eq, ToJson, 
    Debug    )

    DiscountResult

    source
    pub struct DiscountResult {
      original : Money
      discount : Money
      payable : Money
      applied : Array[String]
    } derive(Eq, ToJson, 
    Debug    )

    DiscountResult::effective_rate_bp

    source
    fn DiscountResult::effective_rate_bp(self : DiscountResult) -> Int

    DiscountRule

    source
    pub struct DiscountRule {
      code : String
      percent_bp : Int
      cap : Money
    } derive(Eq, ToJson, 
    Debug    )

    DiscountRule::valid

    source
    fn DiscountRule::valid(self : DiscountRule) -> Bool

    Invoice

    source
    pub struct Invoice {
      id : String
      lines : Array[SettlementLine]
      tax : Money
      paid : Money
    } derive(Eq, ToJson, 
    Debug    )

    Invoice::is_closed

    source
    fn Invoice::is_closed(self : Invoice) -> Bool

    Invoice::line_count

    source
    fn Invoice::line_count(self : Invoice) -> Int

    Invoice::taxable_subtotal

    source
    fn Invoice::taxable_subtotal(self : Invoice) -> Money

    JobState

    source
    pub(all) enum JobState {
      Queued
      Running
      Succeeded
      Failed
      Retrying
    } derive(Eq, ToJson, 
    Debug    )

    Lane

    source
    pub struct Lane {
      origin : String
      destination : String
      zone : String
      transit_days : Int
    } derive(Eq, ToJson, 
    Debug    )

    Lane::is_valid

    source
    fn Lane::is_valid(self : Lane) -> Bool

    Lane::key

    source
    fn Lane::key(self : Lane) -> String

    ManifestIssue

    source
    pub struct ManifestIssue {
      tracking_no : String
      kind : ManifestIssueKind
      detail : String
    } derive(Eq, ToJson, 
    Debug    )

    ManifestIssueKind

    source
    pub(all) enum ManifestIssueKind {
      MissingTracking
      DuplicateTracking
      InvalidWeight
      InvalidDeclaredValue
      UnknownZone
    } derive(Eq, ToJson, 
    Debug    )

    ManifestItem

    source
    pub struct ManifestItem {
      tracking_no : String
      zone : String
      parcel : ParcelDim
      declared_value : Money
    } derive(Eq, ToJson, 
    Debug    )

    ManifestQuote

    source
    pub struct ManifestQuote {
      items : Array[Quote]
      total : Money
    } derive(Eq, ToJson, 
    Debug    )

    ManifestQuote::summary

    source
    fn ManifestQuote::summary(self : ManifestQuote) -> String

    ManifestSummary

    source
    pub struct ManifestSummary {
      count : Int
      total_weight_g : Int
      average_weight_g : Int
      max_weight_g : Int
      min_weight_g : Int
      outlier_count : Int
    } derive(Eq, ToJson, 
    Debug    )

    ManifestSummary::average_kg

    source
    fn ManifestSummary::average_kg(self : ManifestSummary) -> Int

    ManifestSummary::is_empty

    source
    fn ManifestSummary::is_empty(self : ManifestSummary) -> Bool

    ManifestSummary::weight_range

    source
    fn ManifestSummary::weight_range(self : ManifestSummary) -> Int

    ManifestValidation

    source
    pub struct ManifestValidation {
      valid : Bool
      issues : Array[ManifestIssue]
      accepted : Int
    } derive(Eq, ToJson, 
    Debug    )

    ManifestValidation::has_kind

    source
    fn ManifestValidation::has_kind(self : ManifestValidation, kind : ManifestIssueKind) -> Bool

    ManifestValidation::is_empty

    source
    fn ManifestValidation::is_empty(self : ManifestValidation) -> Bool

    ManifestValidation::issue_count

    source
    fn ManifestValidation::issue_count(self : ManifestValidation) -> Int

    Money

    source
    pub struct Money {
      cents : Int
    } derive(Eq, ToJson, 
    Debug    )

    Money::abs

    source
    fn Money::abs(self : Money) -> Money

    Money::add

    source
    fn Money::add(self : Money, other : Money) -> Money

    Money::clamp

    source
    fn Money::clamp(self : Money, low : Money, high : Money) -> Money

    Money::difference

    source
    fn Money::difference(self : Money, other : Money) -> Money

    Money::from_cents

    source
    fn Money::from_cents(cents : Int) -> Money

    Money::is_negative

    source
    fn Money::is_negative(self : Money) -> Bool

    Money::is_positive

    source
    fn Money::is_positive(self : Money) -> Bool

    Money::is_zero

    source
    fn Money::is_zero(self : Money) -> Bool

    Money::max

    source
    fn Money::max(self : Money, other : Money) -> Money

    Money::min

    source
    fn Money::min(self : Money, other : Money) -> Money

    Money::mul_int

    source
    fn Money::mul_int(self : Money, n : Int) -> Money

    Money::negate

    source
    fn Money::negate(self : Money) -> Money

    Money::percent_bp

    source
    fn Money::percent_bp(self : Money, bp : Int) -> Money

    Money::round_to

    source
    fn Money::round_to(self : Money, unit_cents : Int, mode : RoundingMode) -> Money

    Money::scale_bp

    source
    fn Money::scale_bp(self : Money, bp : Int) -> Money

    Money::sub

    source
    fn Money::sub(self : Money, other : Money) -> Money

    Money::to_string

    source
    fn Money::to_string(self : Money) -> String

    Money::yuan

    source
    fn Money::yuan(yuan : Int) -> Money

    Money::zero

    source
    fn Money::zero() -> Money

    OperationalRate

    source
    pub struct OperationalRate {
      code : String
      zone : String
      minimum_g : Int
      maximum_g : Int
      rate : Money
      multiplier_bp : Int
    } derive(Eq, ToJson, 
    Debug    )

    OperationalRate::contains

    source
    fn OperationalRate::contains(self : OperationalRate, weight_g : Int) -> Bool

    OperationalRate::is_valid

    source
    fn OperationalRate::is_valid(self : OperationalRate) -> Bool

    OperationalRate::span

    source
    fn OperationalRate::span(self : OperationalRate) -> Int

    ParcelDim

    source
    pub struct ParcelDim {
      width_cm : Int
      height_cm : Int
      depth_cm : Int
      weight_g : Int
    } derive(Eq, ToJson, 
    Debug    )

    ParcelDim::chargeable_volume_l

    source
    fn ParcelDim::chargeable_volume_l(self : ParcelDim) -> Int

    ParcelDim::dimensional_density

    source
    fn ParcelDim::dimensional_density(self : ParcelDim) -> Int

    ParcelDim::is_valid

    source
    fn ParcelDim::is_valid(self : ParcelDim) -> Bool

    ParcelDim::longest_side_cm

    source
    fn ParcelDim::longest_side_cm(self : ParcelDim) -> Int

    ParcelDim::normalized

    source
    fn ParcelDim::normalized(self : ParcelDim) -> ParcelDim

    ParcelDim::volume_cm3

    source
    fn ParcelDim::volume_cm3(self : ParcelDim) -> Int

    ParcelProfile

    source
    pub struct ParcelProfile {
      longest_side_cm : Int
      shortest_side_cm : Int
      middle_side_cm : Int
      girth_cm : Int
      footprint_cm2 : Int
      surface_area_cm2 : Int
      density_g_per_l : Int
    } derive(Eq, ToJson, 
    Debug    )

    PaymentAllocation

    source
    pub struct PaymentAllocation {
      payment_id : String
      invoice_id : String
      amount : Money
      remaining : Money
    } derive(Eq, ToJson, 
    Debug    )

    PaymentAllocation::fully_settles

    source
    fn PaymentAllocation::fully_settles(self : PaymentAllocation) -> Bool

    PromiseStatus

    source
    pub(all) enum PromiseStatus {
      OnTime
      AtRisk
      Breached
    } derive(Eq, ToJson, 
    Debug    )

    Quote

    source
    pub struct Quote {
      billable_weight_g : Int
      actual_weight_g : Int
      volumetric_weight_g : Int
      subtotal : Money
      total : Money
      lines : Array[ChargeLine]
    } derive(Eq, ToJson, 
    Debug    )

    Quote::summary

    source
    fn Quote::summary(self : Quote) -> String

    ReconciliationItem

    source
    pub struct ReconciliationItem {
      code : String
      expected : Money
      actual : Money
      difference : Money
      status : ReconciliationStatus
    } derive(Eq, ToJson, 
    Debug    )

    ReconciliationReport

    source
    pub struct ReconciliationReport {
      items : Array[ReconciliationItem]
      matched : Int
      exceptions : Int
      net_difference : Money
    } derive(Eq, ToJson, 
    Debug    )

    ReconciliationReport::absolute_difference

    source
    fn ReconciliationReport::absolute_difference(self : ReconciliationReport) -> Money

    ReconciliationReport::is_matched

    source
    fn ReconciliationReport::is_matched(self : ReconciliationReport) -> Bool

    ReconciliationReport::item_count

    source
    fn ReconciliationReport::item_count(self : ReconciliationReport) -> Int

    ReconciliationStatus

    source
    pub(all) enum ReconciliationStatus {
      Matched
      Difference
      MissingExpected
      UnexpectedActual
    } derive(Eq, ToJson, 
    Debug    )

    RoundingMode

    source
    pub(all) enum RoundingMode {
      HalfUp
      HalfDown
      Floor
      Ceiling
    } derive(Eq, ToJson, 
    Debug    )

    RouteEdge

    source
    pub struct RouteEdge {
      from : String
      to : String
      distance_km : Int
      transit_days : Int
      capacity_g : Int
      zone : String
    } derive(Eq, ToJson, 
    Debug    )

    RouteEdge::is_valid

    source
    fn RouteEdge::is_valid(self : RouteEdge) -> Bool

    RouteLeg

    source
    pub struct RouteLeg {
      origin : String
      destination : String
      zone : String
      days : Int
      capacity_g : Int
    } derive(Eq, ToJson, 
    Debug    )

    RoutePlan

    source
    pub struct RoutePlan {
      nodes : Array[String]
      distance_km : Int
      transit_days : Int
      capacity_g : Int
      feasible : Bool
    } derive(Eq, ToJson, 
    Debug    )

    RoutePlan::hop_count

    source
    fn RoutePlan::hop_count(self : RoutePlan) -> Int

    RoutePlan::is_feasible

    source
    fn RoutePlan::is_feasible(self : RoutePlan) -> Bool

    RuleProblem

    source
    pub enum RuleProblem {
      NonPositiveDivisor
      NonPositiveWeightStep
      EmptyZones
      InvalidZoneMultiplier(String)
      NegativeFee(String)
    } derive(Eq, ToJson, 
    Debug    )

    ServicePromise

    source
    pub struct ServicePromise {
      pickup_day : Int
      delivery_day : Int
      latest_day : Int
      status : PromiseStatus
    } derive(Eq, ToJson, 
    Debug    )

    ServicePromise::is_breached

    source
    fn ServicePromise::is_breached(self : ServicePromise) -> Bool

    ServicePromise::is_on_time

    source
    fn ServicePromise::is_on_time(self : ServicePromise) -> Bool

    ServicePromise::slack_days

    source
    fn ServicePromise::slack_days(self : ServicePromise, actual_day : Int) -> Int

    ServiceWindow

    source
    pub struct ServiceWindow {
      service : String
      minimum_days : Int
      maximum_days : Int
      cutoff_hour : Int
    } derive(Eq, ToJson, 
    Debug    )

    SettlementLine

    source
    pub struct SettlementLine {
      code : String
      amount : Money
      taxable : Bool
    } derive(Eq, ToJson, 
    Debug    )

    SurchargePolicy

    source
    pub struct SurchargePolicy {
      overweight_limit_g : Int
      overweight_fee : Money
      oversize_limit_cm : Int
      oversize_fee : Money
      fuel_percent_bp : Int
      insurance_percent_bp : Int
    } derive(Eq, ToJson, 
    Debug    )

    TariffCandidate

    source
    pub struct TariffCandidate {
      id : String
      priority : Int
      effective_from : Int
      effective_to : Int
      predicates : Array[TariffPredicate]
      charge : Money
    } derive(Eq, ToJson, 
    Debug    )

    TariffCandidate::active_on

    source
    fn TariffCandidate::active_on(self : TariffCandidate, day : Int) -> Bool

    TariffCandidate::is_well_formed

    source
    fn TariffCandidate::is_well_formed(self : TariffCandidate) -> Bool

    TariffPredicate

    source
    pub(all) enum TariffPredicate {
      WeightAtLeast(Int)
      WeightAtMost(Int)
      LongestSideAtMost(Int)
      ZoneIs(String)
      DeclaredValueAtLeast(Money)
    } derive(Eq, ToJson, 
    Debug    )

    TaxPolicy

    source
    pub struct TaxPolicy {
      rate_bp : Int
      threshold : Money
    } derive(Eq, ToJson, 
    Debug    )

    TaxPolicy::valid

    source
    fn TaxPolicy::valid(self : TaxPolicy) -> Bool

    TaxResult

    source
    pub struct TaxResult {
      taxable : Money
      exempt : Money
      tax : Money
      gross : Money
    } derive(Eq, ToJson, 
    Debug    )

    TaxResult::net_of_tax

    source
    fn TaxResult::net_of_tax(self : TaxResult) -> Money

    ValidationSummary

    source
    pub struct ValidationSummary {
      errors : Int
      warnings : Int
      infos : Int
      diagnostics : Array[ConfigDiagnostic]
    } derive(Eq, ToJson, 
    Debug    )

    ValidationSummary::diagnostic_count

    source
    fn ValidationSummary::diagnostic_count(self : ValidationSummary) -> Int

    ValidationSummary::has_warnings

    source
    fn ValidationSummary::has_warnings(self : ValidationSummary) -> Bool

    ValidationSummary::is_valid

    source
    fn ValidationSummary::is_valid(self : ValidationSummary) -> Bool

    ZoneRate

    source
    pub struct ZoneRate {
      zone : String
      multiplier_bp : Int
      remote_fee : Money
    } derive(Eq, ToJson, 
    Debug    )

    add_business_days

    source
    fn add_business_days(calendar : BusinessCalendar, start_day : Int, amount : Int) -> Int

    aging_is_overdue

    source
    fn aging_is_overdue(invoice_day : Int, as_of_day : Int) -> Bool

    aging_open_days

    source
    fn aging_open_days(invoice_day : Int, as_of_day : Int) -> Int

    aging_total

    source
    fn aging_total(buckets : Array[AgingBucket]) -> Money

    allocate_payment

    source
    fn allocate_payment(invoice : Invoice, payment_id : String, amount : Money) -> PaymentAllocation

    analyze_parcel

    source
    fn analyze_parcel(parcel : ParcelDim) -> ParcelProfile

    append_audit_event

    source
    fn append_audit_event(chain : AuditChain, event : AuditEvent) -> AuditChain

    apply_discounts

    source
    fn apply_discounts(original : Money, rules : Array[DiscountRule]) -> DiscountResult

    assess_customs

    source
    fn assess_customs(document : CustomsDocument, duty_bp : Int) -> CustomsAssessment

    audit_chain

    source
    fn audit_chain() -> AuditChain

    audit_chain_is_consistent

    source
    fn audit_chain_is_consistent(chain : AuditChain) -> Bool

    audit_chain_with_digest

    source
    fn audit_chain_with_digest(chain : AuditChain, digest : Int) -> AuditChain

    audit_event

    source
    fn audit_event(sequence : Int, code : String, detail : String, amount : Money) -> AuditEvent

    billable_weight_g

    source
    fn billable_weight_g(parcel : ParcelDim, divisor : Int) -> Int

    billing_rule

    source
    fn billing_rule(volumetric_divisor~ : Int, first_weight_limit_g~ : Int, first_weight_rate~ : Money, additional_weight_unit_g~ : Int, additional_weight_rate~ : Money, min_charge~ : Money, zones~ : Array[ZoneRate], surcharge~ : SurchargePolicy) -> BillingRule

    bulk_job

    source
    fn bulk_job(id : String, item_count : Int) -> BulkJob

    business_calendar

    source
    fn business_calendar(weekend_days : Array[Int], holidays : Array[Int], cutoff_hour : Int) -> BusinessCalendar

    calculate_customs

    source
    fn calculate_customs(lines : Array[CustomsLine]) -> CustomsSummary

    calculate_tax

    source
    fn calculate_tax(policy : TaxPolicy, taxable : Money, exempt : Money) -> TaxResult

    choose_tariff

    source
    fn choose_tariff(candidates : Array[TariffCandidate], parcel : ParcelDim, zone : String, declared_value : Money, day : Int) -> DecisionTrace

    combine_discount_rules

    source
    fn combine_discount_rules(groups : Array[Array[DiscountRule]]) -> Array[DiscountRule]

    customs_document

    source
    fn customs_document(hs_code : String, description : String, declared_value : Money, origin : String, restricted : Bool) -> CustomsDocument

    customs_duty

    source
    fn customs_duty(line : CustomsLine) -> Money

    customs_insurance

    source
    fn customs_insurance(line : CustomsLine) -> Money

    customs_line

    source
    fn customs_line(code : String, declared_value : Money, duty_bp : Int, insurance_bp : Int) -> CustomsLine

    describe_line

    source
    fn describe_line(line : ChargeLine) -> String

    discount_rule

    source
    fn discount_rule(code~ : String, percent_bp~ : Int, cap~ : Money) -> DiscountRule

    domestic_rate_catalog

    source
    fn domestic_rate_catalog() -> Array[OperationalRate]

    find_operational_rate

    source
    fn find_operational_rate(catalog : Array[OperationalRate], weight_g : Int) -> OperationalRate

    international_rate_catalog

    source
    fn international_rate_catalog() -> Array[OperationalRate]

    invoice

    source
    fn invoice(id : String, lines : Array[SettlementLine], tax : Money, paid : Money) -> Invoice

    invoice_aging

    source
    fn invoice_aging(invoice : Invoice, invoice_day : Int, as_of_day : Int) -> Array[AgingBucket]

    invoice_balance

    source
    fn invoice_balance(invoice : Invoice) -> (BalanceState, Money)

    invoice_outstanding

    source
    fn invoice_outstanding(invoice : Invoice) -> Money

    invoice_subtotal

    source
    fn invoice_subtotal(invoice : Invoice) -> Money

    invoice_total

    source
    fn invoice_total(invoice : Invoice) -> Money

    is_business_day

    source
    fn is_business_day(calendar : BusinessCalendar, day : Int) -> Bool

    job_after_failure

    source
    fn job_after_failure(job : BulkJob, count : Int, retryable : Bool) -> BulkJob

    job_after_success

    source
    fn job_after_success(job : BulkJob, count : Int) -> BulkJob

    lane

    source
    fn lane(origin~ : String, destination~ : String, zone~ : String, transit_days~ : Int) -> Lane

    make_service_promise

    source
    fn make_service_promise(calendar : BusinessCalendar, pickup_day : Int, pickup_hour : Int, transit_days : Int, buffer_days : Int, actual_delivery_day : Int) -> ServicePromise

    manifest_item

    source
    fn manifest_item(tracking_no : String, zone : String, parcel : ParcelDim, declared_value : Money) -> ManifestItem

    parcel_dim

    source
    fn parcel_dim(width_cm~ : Int, height_cm~ : Int, depth_cm~ : Int, weight_g~ : Int) -> ParcelDim

    plan_route

    source
    fn plan_route(edges : Array[RouteEdge], origin : String, destination : String, max_hops : Int, capacity_g : Int) -> RoutePlan

    quote

    source
    fn quote(rule : BillingRule, parcel : ParcelDim, zone : String, declared_value : Money) -> Quote

    quote_manifest

    source
    fn quote_manifest(rule : BillingRule, items : Array[ManifestItem]) -> ManifestQuote

    reconcile_lines

    source
    fn reconcile_lines(expected : Array[SettlementLine], actual : Array[SettlementLine], tolerance : Money) -> ReconciliationReport

    regional_rate_catalog

    source
    fn regional_rate_catalog() -> Array[OperationalRate]

    resolve_lane

    source
    fn resolve_lane(lanes : Array[Lane], origin : String, destination : String) -> Lane

    returns_rate_catalog

    source
    fn returns_rate_catalog() -> Array[OperationalRate]

    route_edge

    source
    fn route_edge(from : String, to : String, distance_km : Int, transit_days : Int, capacity_g : Int, zone : String) -> RouteEdge

    route_leg

    source
    fn route_leg(origin : String, destination : String, zone : String, days : Int, capacity_g : Int) -> RouteLeg

    sample_manifest

    source
    fn sample_manifest() -> Array[ManifestItem]

    select_fastest_lane

    source
    fn select_fastest_lane(lanes : Array[Lane], origin : String, destination : String) -> Lane

    service_deadline

    source
    fn service_deadline(calendar : BusinessCalendar, start_day : Int, start_hour : Int, transit_days : Int, buffer_days : Int) -> Int

    service_window

    source
    fn service_window(service : String, minimum_days : Int, maximum_days : Int, cutoff_hour : Int) -> ServiceWindow

    settlement_line

    source
    fn settlement_line(code : String, amount : Money, taxable : Bool) -> SettlementLine

    standard_rule

    source
    fn standard_rule() -> BillingRule

    summarize_manifest

    source
    fn summarize_manifest(values : Array[ParcelDim]) -> ManifestSummary

    surcharge_policy

    source
    fn surcharge_policy(overweight_limit_g~ : Int, overweight_fee~ : Money, oversize_limit_cm~ : Int, oversize_fee~ : Money, fuel_percent_bp~ : Int, insurance_percent_bp~ : Int) -> SurchargePolicy

    tariff_candidate

    source
    fn tariff_candidate(id : String, priority : Int, effective_from : Int, effective_to : Int, predicates : Array[TariffPredicate], charge : Money) -> TariffCandidate

    tax_policy

    source
    fn tax_policy(rate_bp~ : Int, threshold~ : Money) -> TaxPolicy

    validate_configuration

    source
    fn validate_configuration(entries : Array[String]) -> ValidationSummary

    validate_manifest

    source
    fn validate_manifest(items : Array[ManifestItem]) -> ManifestValidation

    validate_rule

    source
    fn validate_rule(rule : BillingRule) -> Array[RuleProblem]

    volumetric_weight_g

    source
    fn volumetric_weight_g(parcel : ParcelDim, divisor : Int) -> Int

    zone_rate

    source
    fn zone_rate(zone~ : String, multiplier_bp~ : Int, remote_fee~ : Money) -> ZoneRate

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io