pub struct AcceptingPath[W] {
  final_weight : W
  total : W
  // private fields
}

pub(all) struct Arc[W] {
  input : Label
  output : Label
  destination : Int
  weight : W
}

pub(all) enum Label {
  Epsilon
  Symbol(String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct PathOrder[W] {
  compare : (W, W) -> Int
  is_nonnegative : (W) -> Bool
  is_zero : (W) -> Bool
}

pub(all) struct PathStep[W] {
  source : Int
  arc : Arc[W]
}

pub(all) struct Semiring[W] {
  zero : W
  one : W
  plus : (W, W) -> W
  times : (W, W) -> W
}

pub struct Transducer[W] {
  semiring : Semiring[W]
  start : Int?
  // private fields
}

pub struct TransducerBuilder[W] {
  semiring : Semiring[W]
  start : Int?
  // private fields
}

pub(all) struct TransducerStats {
  state_count : Int
  arc_count : Int
  epsilon_input_arc_count : Int
  epsilon_output_arc_count : Int
  final_state_count : Int
  max_out_degree : Int
  reachable_state_count : Int
  coaccessible_state_count : Int
  has_start : Bool
} derive(Eq)

pub struct TrimResult[W] {
  graph : Transducer[W]
  // private fields
}

pub enum TropicalWeight {
  Finite(Int)
  Infinity
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum WfstError {
  InvalidStateId(Int)
  NoStartState
  UnsupportedEpsilonComposition
  GraphHasCycle
  InvalidPathLimit(Int)
  NegativeWeight
  WeightOutOfRange
  NoAcceptingPath
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn[W] accepting_core_states(transducer : Transducer[W]) -> Array[Bool]

fn[W] accepting_path_final_weight(path : AcceptingPath[W]) -> W

fn[W] accepting_path_states(path : AcceptingPath[W]) -> Array[Int]

fn[W] accepting_path_steps(path : AcceptingPath[W]) -> Array[PathStep[W]]

fn[W] accepting_path_total_weight(path : AcceptingPath[W]) -> W

fn[W] accepts_pair(transducer : Transducer[W], input : Array[String], output : Array[String], is_zero : (W) -> Bool) -> Result[Bool, WfstError]

fn[W] add_arc(builder : TransducerBuilder[W], source : Int, input : Label, output : Label, destination : Int, weight : W) -> Result[Unit, WfstError]

fn[W] add_state(builder : TransducerBuilder[W]) -> Int

fn[W] backward_weights_in_dag(transducer : Transducer[W]) -> Result[Array[W], WfstError]

fn boolean_semiring() -> Semiring[Bool]

fn[W] build_transducer(builder : TransducerBuilder[W]) -> Transducer[W]

fn[W] clear_final(builder : TransducerBuilder[W], state : Int) -> Result[Unit, WfstError]

fn[W] coaccessible_states(transducer : Transducer[W]) -> Array[Bool]

fn[W] compose(left : Transducer[W], right : Transducer[W]) -> Result[Transducer[W], WfstError]

fn[W] concatenate_transducers(left : Transducer[W], right : Transducer[W]) -> Transducer[W]

fn[W] forward_weights_in_dag(transducer : Transducer[W]) -> Result[Array[W], WfstError]

fn[W] invert(transducer : Transducer[W]) -> Transducer[W]

fn label_is_epsilon(label : Label) -> Bool

fn[W] path_order(compare : (W, W) -> Int, is_nonnegative : (W) -> Bool, is_zero : (W) -> Bool) -> PathOrder[W]

fn[W] project_input(transducer : Transducer[W]) -> Transducer[W]

fn[W] project_output(transducer : Transducer[W]) -> Transducer[W]

fn[W] reachable_states(transducer : Transducer[W]) -> Array[Bool]

fn[W] reachable_states_from(transducer : Transducer[W], root : Int) -> Result[Array[Bool], WfstError]

fn[W] semiring_one(semiring : Semiring[W]) -> W

fn[W] semiring_plus(semiring : Semiring[W], left : W, right : W) -> W

fn[W] semiring_times(semiring : Semiring[W], left : W, right : W) -> W

fn[W] semiring_zero(semiring : Semiring[W]) -> W

fn[W] set_final(builder : TransducerBuilder[W], state : Int, weight : W) -> Result[Unit, WfstError]

fn[W] set_start(builder : TransducerBuilder[W], state : Int) -> Result[Unit, WfstError]

fn[W] shortest_path(transducer : Transducer[W], order : PathOrder[W]) -> Result[AcceptingPath[W], WfstError]

fn[W] shortest_paths_in_dag(transducer : Transducer[W], order : PathOrder[W], limit : Int) -> Result[Array[AcceptingPath[W]], WfstError]

fn[W] topological_order(transducer : Transducer[W]) -> Result[Array[Int], WfstError]

fn[W] total_weight_in_dag(transducer : Transducer[W]) -> Result[W, WfstError]

fn[W] transducer_arcs_from(transducer : Transducer[W], state : Int) -> Result[Array[Arc[W]], WfstError]

fn[W] transducer_builder(semiring : Semiring[W]) -> TransducerBuilder[W]

fn[W] transducer_final_weight(transducer : Transducer[W], state : Int) -> Result[W?, WfstError]

fn[W] transducer_has_epsilon(transducer : Transducer[W]) -> Bool

fn[W] transducer_incoming_arcs(transducer : Transducer[W], destination : Int) -> Result[Array[(Int, Arc[W])], WfstError]

fn[W] transducer_is_trimmed(transducer : Transducer[W]) -> Bool

fn[W] transducer_semiring(transducer : Transducer[W]) -> Semiring[W]

fn[W] transducer_start_state(transducer : Transducer[W]) -> Int?

fn[W] transducer_state_count(transducer : Transducer[W]) -> Int

fn[W] transducer_stats(transducer : Transducer[W]) -> TransducerStats

fn[W] trim(transducer : Transducer[W]) -> TrimResult[W]

fn[W] trim_result_state_mapping(result : TrimResult[W]) -> Array[Int?]

fn[W] trim_result_transducer(result : TrimResult[W]) -> Transducer[W]

fn tropical_compare(left : TropicalWeight, right : TropicalWeight) -> Int

fn tropical_cost(cost : Int) -> Result[TropicalWeight, WfstError]

fn tropical_infinity() -> TropicalWeight

fn tropical_is_infinite(weight : TropicalWeight) -> Bool

fn tropical_path_order() -> PathOrder[TropicalWeight]

fn tropical_semiring() -> Semiring[TropicalWeight]

fn tropical_value(weight : TropicalWeight) -> Int?

fn[W] union_transducers(left : Transducer[W], right : Transducer[W]) -> Transducer[W]