ledgerweave

pub(all) struct AccountTotal {
  account_id : String
  order_count : Int
  expected_minor : Int
  captured_minor : Int
  refunded_minor : Int
  outstanding_minor : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum AdjustmentDirection {
  Credit
  Debit
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct AdjustmentRecord {
  id : String
  order_id : String
  currency : String
  amount_minor : Int
  day : Int
  direction : AdjustmentDirection
  reason : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct AgeBucket {
  label : String
  order_count : Int
  outstanding_minor : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct AllocationPlan {
  allocations : Array[PaymentAllocation]
  unallocated_minor : Int
  allocated_minor : Int
  ignored_minor : Int
  valid : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum AllocationState {
  Applied
  UnmatchedPayment
  OverAllocation
  CurrencyConflict
  IgnoredPayment
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct AssignmentRule {
  code : FindingCode
  owner : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct CodeCount {
  code : FindingCode
  count : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct CurrencyTotal {
  currency : String
  order_count : Int
  expected_minor : Int
  captured_minor : Int
  refunded_minor : Int
  outstanding_minor : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Finding {
  code : FindingCode
  severity : Severity
  record_kind : RecordKind
  record_id : String
  order_id : String
  message : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum FindingCode {
  DuplicateOrderId
  DuplicatePaymentId
  DuplicateRefundId
  DuplicateAdjustmentId
  InvalidAmount
  InvalidCurrency
  UnknownOrder
  CurrencyMismatch
  PaymentAfterDeadline
  PaymentForCancelledOrder
  RefundExceedsPayment
  Overpaid
  Underpaid
  OpenPastDue
  PaymentVoided
  MissingReference
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct FindingMetrics {
  total : Int
  info : Int
  warning : Int
  error : Int
  blocking : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct FindingQuery {
  minimum_severity : Severity
  code : FindingCode?
  order_id : String?
  record_kind : RecordKind?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct InputQualityReport {
  orders : SourceProfile
  payments : SourceProfile
  refunds : SourceProfile
  adjustments : SourceProfile
  issues : Array[QualityIssue]
  ready : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct LedgerInput {
  orders : Array[OrderRecord]
  payments : Array[PaymentRecord]
  refunds : Array[RefundRecord]
  adjustments : Array[AdjustmentRecord]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct MatchingCandidate {
  payment_id : String
  order_id : String
  score : Int
  reason : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct OrderBalance {
  order_id : String
  expected_minor : Int
  captured_minor : Int
  refunded_minor : Int
  adjustments_minor : Int
  outstanding_minor : Int
  resolution : Resolution
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct OrderRecord {
  id : String
  account_id : String
  currency : String
  amount_minor : Int
  created_day : Int
  status : OrderStatus
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum OrderStatus {
  Pending
  Paid
  Cancelled
  Refunded
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct PaymentAllocation {
  payment_id : String
  order_id : String
  currency : String
  allocated_minor : Int
  state : AllocationState
  note : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct PaymentRecord {
  id : String
  order_id : String
  currency : String
  amount_minor : Int
  received_day : Int
  status : PaymentStatus
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum PaymentStatus {
  Captured
  Voided
  Failed
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Policy {
  allowed_currencies : Array[String]
  amount_tolerance_minor : Int
  max_payment_lag_days : Int
  max_open_age_days : Int
  permit_cancelled_payment : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct QualityIssue {
  source : SourceKind
  row_number : Int
  record_id : String
  order_id : String
  code : QualityIssueCode
  severity : Severity
  message : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum QualityIssueCode {
  BlankIdentifier
  BlankAccount
  BlankReference
  UnsupportedCurrency
  NonPositiveAmount
  NegativeDay
  DuplicateIdentifier
  OrphanReference
  MissingReason
  InvalidStatusCombination
  FutureDatedRecord
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ReconciliationResult {
  balances : Array[OrderBalance]
  findings : Array[Finding]
  valid : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum RecordKind {
  Order
  Payment
  Refund
  Adjustment
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct RefundRecord {
  id : String
  order_id : String
  currency : String
  amount_minor : Int
  refunded_day : Int
  reason : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Resolution {
  Settled
  AwaitingPayment
  OverCollected
  RefundRisk
  NeedsReview
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ResolutionCount {
  resolution : Resolution
  count : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ResultMetrics {
  finding_metrics : FindingMetrics
  settled_orders : Int
  awaiting_payment_orders : Int
  over_collected_orders : Int
  refund_risk_orders : Int
  review_orders : Int
  expected_minor : Int
  captured_minor : Int
  refunded_minor : Int
  outstanding_minor : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ReviewCase {
  case_id : String
  finding : Finding
  priority : Int
  state : ReviewState
  owner : String
  opened_day : Int
  updated_day : Int
  decision : ReviewDecision
  resolution_note : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum ReviewDecision {
  ConfirmedIssue
  DataCorrection
  BusinessException
  FalsePositive
  NoDecision
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ReviewQueue {
  cases : Array[ReviewCase]
  next_sequence : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum ReviewState {
  Open
  Investigating
  Resolved
  Dismissed
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ReviewSummary {
  open : Int
  investigating : Int
  resolved : Int
  dismissed : Int
  unassigned : Int
  overdue : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Severity {
  Info
  Warning
  Error
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum SourceKind {
  OrdersSource
  PaymentsSource
  RefundsSource
  AdjustmentsSource
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SourceProfile {
  source : SourceKind
  record_count : Int
  blank_identifier_count : Int
  duplicate_identifier_count : Int
  invalid_amount_count : Int
  blank_reference_count : Int
  orphan_reference_count : Int
  invalid_currency_count : Int
  future_day_count : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn abs_int(value : Int) -> Int

fn age_bucket_label(age_days : Int) -> String

fn allocate_payments(input : LedgerInput, result : ReconciliationResult) -> AllocationPlan

fn allocated_for_order(allocations : Array[PaymentAllocation], order_id : String) -> Int

fn allocation_plan_is_consistent(plan : AllocationPlan) -> Bool

fn allocation_state_label(state : AllocationState) -> String

fn allocations_for_order(allocations : Array[PaymentAllocation], order_id : String) -> Array[PaymentAllocation]

fn allocations_for_payment(allocations : Array[PaymentAllocation], payment_id : String) -> Array[PaymentAllocation]

fn assign_case(queue : ReviewQueue, wanted : String, owner : String, updated_day : Int) -> ReviewQueue

fn auto_assign(queue : ReviewQueue, rules : Array[AssignmentRule], updated_day : Int) -> ReviewQueue

fn balance_age(input : LedgerInput, order_id : String, current_day : Int) -> Int?

fn balances_above_outstanding(balances : Array[OrderBalance], threshold_minor : Int) -> Array[OrderBalance]

fn balances_below_outstanding(balances : Array[OrderBalance], threshold_minor : Int) -> Array[OrderBalance]

fn best_candidate(input : LedgerInput, payment : PaymentRecord) -> MatchingCandidate?

fn blocking_quality_issues(report : InputQualityReport) -> Array[QualityIssue]

fn can_transition(from : ReviewState, to : ReviewState) -> Bool

fn candidate_score(payment : PaymentRecord, order : OrderRecord) -> Int

fn captured_payment_amount(payment : PaymentRecord) -> Int

fn case_age(case : ReviewCase, current_day : Int) -> Int

fn cases_for_order(cases : Array[ReviewCase], order_id : String) -> Array[ReviewCase]

fn cases_for_owner(cases : Array[ReviewCase], owner : String) -> Array[ReviewCase]

fn cases_for_state(cases : Array[ReviewCase], state : ReviewState) -> Array[ReviewCase]

fn clean_input() -> LedgerInput

fn contains_string(items : Array[String], wanted : String) -> Bool

fn count_balances_by_resolution(balances : Array[OrderBalance], resolution : Resolution) -> Int

fn count_findings_by_code(findings : Array[Finding], code : FindingCode) -> Int

fn count_string(items : Array[String], wanted : String) -> Int

fn csv_escape(value : String) -> String

fn decide_case(queue : ReviewQueue, wanted : String, decision : ReviewDecision, note : String, updated_day : Int) -> ReviewQueue

fn default_policy() -> Policy

fn demo_input() -> LedgerInput

fn empty_allocation_plan() -> AllocationPlan

fn empty_finding_metrics() -> FindingMetrics

fn empty_input() -> LedgerInput

fn empty_input_quality_report() -> InputQualityReport

fn empty_result_metrics() -> ResultMetrics

fn empty_review_queue() -> ReviewQueue

fn empty_review_summary() -> ReviewSummary

fn empty_source_profile(source : SourceKind) -> SourceProfile

fn enqueue_finding(queue : ReviewQueue, finding : Finding, opened_day : Int) -> ReviewQueue

fn enqueue_findings(queue : ReviewQueue, findings : Array[Finding], opened_day : Int) -> ReviewQueue

fn error_findings(findings : Array[Finding]) -> Array[Finding]

fn excess_for_payment(allocations : Array[PaymentAllocation], payment_id : String) -> Int

fn export_is_safe_csv(text : String) -> Bool

fn filter_findings(findings : Array[Finding], query : FindingQuery) -> Array[Finding]

fn find_balance(balances : Array[OrderBalance], order_id : String) -> OrderBalance?

fn find_case_index(cases : Array[ReviewCase], wanted : String) -> Int

fn find_order(input : LedgerInput, order_id : String) -> OrderRecord?

fn find_review_case(cases : Array[ReviewCase], wanted : String) -> ReviewCase?

fn finding_code_counts(findings : Array[Finding]) -> Array[CodeCount]

fn finding_code_label(value : FindingCode) -> String

fn finding_metrics(findings : Array[Finding]) -> FindingMetrics

fn findings_for_kind(findings : Array[Finding], kind : RecordKind) -> Array[Finding]

fn findings_for_order(findings : Array[Finding], order_id : String) -> Array[Finding]

fn ignored_allocations(plan : AllocationPlan) -> Array[PaymentAllocation]

fn input_quality_report_is_consistent(report : InputQualityReport) -> Bool

fn inspect_input_quality(input : LedgerInput, policy : Policy, current_day : Int) -> InputQualityReport

fn is_blank(value : String) -> Bool

fn is_eligible_payment(payment : PaymentRecord) -> Bool

fn is_healthy(result : ReconciliationResult) -> Bool

fn is_overdue(case : ReviewCase, current_day : Int, max_age_days : Int) -> Bool

fn is_terminal_state(state : ReviewState) -> Bool

fn make_finding(code : FindingCode, severity : Severity, record_kind : RecordKind, record_id : String, order_id : String, message : String) -> Finding

fn matching_candidates(input : LedgerInput, payment : PaymentRecord) -> Array[MatchingCandidate]

fn max_outstanding_balance(balances : Array[OrderBalance]) -> OrderBalance?

fn min_outstanding_balance(balances : Array[OrderBalance]) -> OrderBalance?

fn new_review_case(finding : Finding, sequence : Int, opened_day : Int) -> ReviewCase

fn open_cases(cases : Array[ReviewCase]) -> Array[ReviewCase]

fn outstanding_by_age(input : LedgerInput, result : ReconciliationResult, current_day : Int) -> Array[AgeBucket]

fn over_allocations(plan : AllocationPlan) -> Array[PaymentAllocation]

fn overdue_cases(cases : Array[ReviewCase], current_day : Int, max_age_days : Int) -> Array[ReviewCase]

fn parse_adjustments_csv(text : String) -> Array[AdjustmentRecord]

fn parse_csv(text : String) -> Array[Array[String]]

fn parse_day(text : String) -> Int

fn parse_ledger_csv(orders : String, payments : String, refunds : String, adjustments : String) -> LedgerInput

fn parse_orders_csv(text : String) -> Array[OrderRecord]

fn parse_payments_csv(text : String) -> Array[PaymentRecord]

fn parse_refunds_csv(text : String) -> Array[RefundRecord]

fn payment_matches_order(payment : PaymentRecord, order : OrderRecord) -> Bool

fn priority_for_severity(severity : Severity) -> Int

fn priority_label(priority : Int) -> String

fn quality_issue(source : SourceKind, row_number : Int, record_id : String, order_id : String, code : QualityIssueCode, message : String) -> QualityIssue

fn quality_issue_code_label(code : QualityIssueCode) -> String

fn quality_issues_for_code(report : InputQualityReport, code : QualityIssueCode) -> Array[QualityIssue]

fn quality_issues_for_source(report : InputQualityReport, source : SourceKind) -> Array[QualityIssue]

fn quality_score(result : ReconciliationResult) -> Int

fn quality_severity(code : QualityIssueCode) -> Severity

fn queue_from_result(result : ReconciliationResult, opened_day : Int) -> ReviewQueue

fn reconcile(input : LedgerInput, policy : Policy, current_day : Int) -> ReconciliationResult

fn remaining_expected(balance : OrderBalance) -> Int

fn render_account_totals_csv(totals : Array[AccountTotal]) -> String

fn render_age_buckets_csv(buckets : Array[AgeBucket]) -> String

fn render_allocation_csv(plan : AllocationPlan) -> String

fn render_allocation_plan(plan : AllocationPlan) -> String

fn render_audit_bundle(input : LedgerInput, result : ReconciliationResult, current_day : Int) -> String

fn render_balances(result : ReconciliationResult) -> String

fn render_code_counts_markdown(counts : Array[CodeCount]) -> String

fn render_currency_totals_csv(totals : Array[CurrencyTotal]) -> String

fn render_findings(result : ReconciliationResult) -> String

fn render_findings_csv(findings : Array[Finding]) -> String

fn render_metrics_markdown(metrics : ResultMetrics) -> String

fn render_quality_issues_csv(report : InputQualityReport) -> String

fn render_quality_report(report : InputQualityReport) -> String

fn render_review_case(case : ReviewCase) -> String

fn render_review_queue(queue : ReviewQueue) -> String

fn render_review_queue_csv(queue : ReviewQueue) -> String

fn render_summary(result : ReconciliationResult) -> String

fn reopen_case(queue : ReviewQueue, wanted : String, updated_day : Int) -> ReviewQueue

fn resolution_counts(result : ReconciliationResult) -> Array[ResolutionCount]

fn resolution_label(value : Resolution) -> String

fn resolution_rank(resolution : Resolution) -> Int

fn result_metrics(result : ReconciliationResult) -> ResultMetrics