pub(all) suberror LoomError {
  LoomError(String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct BatchResult {
  rows : Array[Result[Array[String], String]]
  failures : Int
}

pub(all) struct Candidate {
  expression : Expr
  cost : Int
}

pub(all) enum Condition {
  Equals(Expr, Expr)
  Matches(Expr, String, Bool)
  Empty(Expr)
  Not(Condition)
  All(Array[Condition])
  Any(Array[Condition])
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Disagreement {
  row_index : Int
  groups : Array[PredictionGroup]
  score : Int
}

pub(all) struct Example {
  input : Array[String]
  output : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Expr {
  Field(Int)
  Literal(String)
  Slice(Expr, Position, Position)
  Token(Expr, String, Int)
  Run(Expr, RunKind, Int)
  Trim(Expr)
  Lower(Expr)
  Upper(Expr)
  Concat(Array[Expr])
  DateText(Expr, String, String)
  If(Condition, Expr, Expr)
  RegexCapture(Expr, String, Int, Int)
  RegexReplace(Expr, String, String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum GroupMetric {
  RowCount
  SumInt64(String)
  MinInt64(String)
  MaxInt64(String)
}

pub(all) struct Measure {
  name : String
  metric : GroupMetric
}

pub(all) struct OutputField {
  name : String
  expression : Expr
}

pub(all) struct Pipeline {
  columns : Array[String]
  steps : Array[TableStep]
}

pub(all) enum Position {
  Start(Int)
  End(Int)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct PredictionGroup {
  prediction : Result[String, String]
  candidates : Array[Int]
}

pub(all) struct Recipe {
  columns : Array[String]
  outputs : Array[OutputField]
}

pub(all) enum RunKind {
  Digits
  Letters
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct SearchOptions {
  max_candidates : Int
  max_parts : Int
  max_atom_evaluations : Int
  max_steps : Int
  max_frontier : Int
}

pub(all) struct SearchReport {
  candidates : Array[Candidate]
  status : String
  truncated : Bool
  atom_evaluations : Int
  atoms : Int
  steps : Int
  cached_states : Int
  cache_hits : Int
}

pub(all) struct Table {
  columns : Array[String]
  rows : Array[Array[String]]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct TableExample {
  before : Table
  after : Table
}

pub(all) struct TableSearchOptions {
  max_depth : Int
  max_states : Int
  max_evaluations : Int
  max_candidates : Int
}

pub(all) struct TableSearchReport {
  candidates : Array[Pipeline]
  truncated : Bool
  status : String
  states : Int
  evaluations : Int
  rejected : Int
  row_searches : Int
}

pub(all) enum TableStep {
  Select(Array[String], Array[String])
  Filter(Condition)
  MapRows(Recipe)
  SplitColumn(String, String, Array[String])
  Explode(String, String)
  Unpivot(Array[String], Array[String], String, String)
  Fold(Array[String], Array[String], String)
  Melt(Array[String], Array[String], String, String, Bool)
  PackRows(Int, Bool)
  GroupRows(Array[String], Array[String])
  Aggregate(Array[String], Array[Measure])
  Pivot(Array[String], String, String, Array[String])
  PivotGrid(Array[String], String, String)
  CombineColumns(Array[String], String, String)
  SegmentRows(Condition, Bool)
  CarryContext(Condition, Array[String])
  Transpose
  PromoteHeaders
  DemoteHeaders
  FillDown(Array[String])
  Deduplicate(Array[String])
  DropRows(Int)
}

fn apply_pipeline(p : Pipeline, table : Table) -> Table raise LoomError

fn apply_recipe(recipe : Recipe, table : Table) -> BatchResult raise LoomError

fn attempt(expr : Expr, row : Array[String]) -> Result[String, String]

fn condition_from_json(v : 
@moonbitlang/core/json.Json
Json) -> Condition raise LoomError

fn condition_to_json(c : Condition) -> 
@moonbitlang/core/json.Json
Json raise LoomError

fn convert_date(text : String, source : String, target : String) -> String raise LoomError

fn date_formats() -> Array[String]

fn default_options() -> SearchOptions

fn default_table_options() -> TableSearchOptions

fn disagreements(candidates : Array[Candidate], rows : Array[Array[String]], limit? : Int) -> Array[Disagreement] raise LoomError

fn evaluate(expr : Expr, row : Array[String]) -> String raise LoomError

fn explain(expr : Expr) -> String

fn explain_condition(c : Condition) -> String

fn expression_from_json(value : 
@moonbitlang/core/json.Json
Json) -> Expr raise LoomError

fn expression_to_json(e : Expr) -> 
@moonbitlang/core/json.Json
Json raise LoomError

fn handle(request : String) -> String

fn parse_csv(source : String) -> Table raise LoomError

fn parse_jsonl(source : String) -> Table raise LoomError

fn pipeline_cost(p : Pipeline) -> Int

fn pipeline_from_json(v : 
@moonbitlang/core/json.Json
Json) -> Pipeline raise LoomError

fn pipeline_to_json(p : Pipeline) -> 
@moonbitlang/core/json.Json
Json raise LoomError

fn recipe_from_json(value : 
@moonbitlang/core/json.Json
Json) -> Recipe raise LoomError

fn recipe_to_json(recipe : Recipe) -> 
@moonbitlang/core/json.Json
Json raise LoomError

fn render_csv(table : Table, spreadsheet_safe? : Bool) -> String raise LoomError

fn synthesize(examples : Array[Example], options? : SearchOptions, separators? : Array[String], patterns? : Array[String], branch_depth? : Int) -> SearchReport raise LoomError

fn synthesize_table(examples : Array[TableExample], options? : TableSearchOptions, separators? : Array[String], patterns? : Array[String]) -> TableSearchReport raise LoomError

fn table_step_from_json(v : 
@moonbitlang/core/json.Json
Json) -> TableStep raise LoomError

fn table_step_to_json(step : TableStep) -> 
@moonbitlang/core/json.Json
Json raise LoomError

fn test_condition(c : Condition, row : Array[String]) -> Bool raise LoomError

fn transform_table(table : Table, steps : Array[TableStep]) -> Table raise LoomError

fn validate_table(table : Table) -> Unit raise LoomError