pub(all) struct BarMap {
  bar : Int
  stock_id : String
  usable_start : Int
  usable_end : Int
  cuts : Array[Cut]
  remnant_start : Int
  remnant_end : Int
  reusable : Bool
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Bound {
  cost : Int
  bars : Int
  possible : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Comparison {
  cost_delta : Int
  purchased_delta : Int
  bars_delta : Int
  ordering : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Cut {
  demand_id : String
  ordinal : Int
  start : Int
  end : Int
  kerf_end : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Demand {
  id : String
  material : String
  length : Int
  quantity : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct KerfScenario {
  kerf : Int
  status : Status
  cost : Int?
  purchased : Int?
  search_work : Int
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Limits {
  patterns : Int
  nodes : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Pattern {
  stock : Int
  counts : Array[Int]
  used : Int
  remaining : Int
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct PatternGroup {
  stock_id : String
  counts : Array[Int]
  repetitions : Int
  remaining_each : Int
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct PatternSet {
  entries : Array[Pattern]
  complete : Bool
  visited : Int
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct Plan {
  bars : Array[Pattern]
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct Problem {
  demands : Array[Demand]
  stocks : Array[Stock]
  kerf : Int
  min_remnant : Int
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Remnant {
  source_bar : Int
  source_stock : String
  material : String
  length : Int
  start : Int
  end : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Solution {
  source : Problem
  status : Status
  plan : Plan?
  pattern_complete : Bool
  search_complete : Bool
  pattern_visits : Int
  pattern_count : Int
  work : Int
  pruned : Int
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Status {
  Optimal
  FeasibleBudget
  Infeasible
  UnknownBudget
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Stock {
  id : String
  material : String
  length : Int
  cost : Int
  quantity : Int
  trim_start : Int
  trim_end : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Totals {
  cost : Int
  purchased : Int
  useful : Int
  kerf_loss : Int
  trim_loss : Int
  reusable : Int
  scrap : Int
  bars : Int
  pieces : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn audit(p : Problem, plan : Plan) -> Result[Totals, String]

fn compare_plans(p : Problem, baseline : Plan, candidate : Plan) -> Result[Comparison, String]

fn cutting_map(p : Problem, plan : Plan) -> Result[Array[BarMap], String]

fn decode_csv(text : String, kerf? : Int, min_remnant? : Int) -> Result[Problem, String]

fn decode_plan(p : Problem, text : String) -> Result[Plan, String]

fn decode_problem(text : String) -> Result[Problem, String]

fn default_limits() -> Limits

fn demand(id : String, material : String, length : Int, quantity : Int) -> Demand

fn demand_output(p : Problem, plan : Plan) -> Result[Array[Int], String]

fn empty_plan() -> Plan

fn encode_csv(p : Problem) -> String

fn encode_plan(p : Problem, plan : Plan) -> Result[String, String]

fn encode_problem(p : Problem) -> String

fn encode_solution(p : Problem, s : Solution) -> Result[String, String]

fn enumerate_patterns(p : Problem, visit_limit? : Int) -> Result[PatternSet, String]

fn expand_groups(p : Problem, groups : Array[PatternGroup]) -> Result[Plan, String]

fn greedy(p : Problem) -> Plan?

fn group_patterns(p : Problem, plan : Plan) -> Result[Array[PatternGroup], String]

fn help_text() -> String

fn kerf_scenarios(p : Problem, kerfs : Array[Int], limits? : Limits) -> Result[Array[KerfScenario], String]

fn lower_bound(p : Problem) -> Bound

fn pattern(p : Problem, stock_index : Int, counts : Array[Int]) -> Result[Pattern, String]

fn plan_from_patterns(p : Problem, bars : Array[Pattern]) -> Result[Plan, String]

fn problem(demands : Array[Demand], stocks : Array[Stock], kerf? : Int, min_remnant? : Int) -> Result[Problem, String]

fn remnant_stocks(p : Problem, plan : Plan) -> Result[Array[Stock], String]

fn remnants(p : Problem, plan : Plan) -> Result[Array[Remnant], String]

fn rollover(p : Problem, plan : Plan, next_demands : Array[Demand], keep_inventory? : Bool) -> Result[Problem, String]

fn run_command(command : String, input : String, args? : Array[String]) -> Result[String, String]

fn solve(p : Problem, limits? : Limits) -> Result[Solution, String]

fn status_name(status : Status) -> String

fn stock(id : String, material : String, length : Int, cost : Int, quantity : Int, trim_start? : Int, trim_end? : Int) -> Stock

fn stock_usage(p : Problem, plan : Plan) -> Result[Array[Int], String]

fn text_report(p : Problem, s : Solution) -> Result[String, String]

fn validate_limits(limits : Limits) -> Result[Unit, String]

fn verify_cutting_map(p : Problem, plan : Plan, maps : Array[BarMap]) -> Bool

fn with_costs(p : Problem, costs : Array[Int]) -> Result[Problem, String]

fn with_inventory(p : Problem, quantities : Array[Int]) -> Result[Problem, String]

fn with_kerf(p : Problem, kerf : Int) -> Result[Problem, String]