pub suberror SchemaError {
  SchemaError(String)
}

pub(all) struct Blueprint {
  total : Int
  per_level : Array[(Int, Int)]
  seed : Int
  exclude : Array[String]
  max_per_tag : Int
}

pub(all) struct Certificate {
  fields : Array[(String, String)]
  payload : Array[Rat]
  robust : Bool
}

pub enum CmpOp {
  CLt
  CLe
  CGt
  CGe
  CEq
  CNe
}

pub enum Expr {
  ELit(Rat)
  EVar(String)
  ENeg(Expr)
  EAdd(Expr, Expr)
  ESub(Expr, Expr)
  EMul(Expr, Expr)
  EDiv(Expr, Expr)
  EPow(Expr, Int)
}

pub enum Family {
  FQuadratic
  FRational
}

pub(all) struct Item {
  schema_name : String
  question : String
  answers : Array[Rat]
  level : Int
  reasons : Array[String]
  fingerprint : String
  certificate : Certificate
  robust : Bool
  signature : String
  family : Family
  tags : Array[String]
}

pub(all) struct ItemFile {
  question : String
  answers : Array[Rat]
  level : Int
  fingerprint : String
  family : Family
  payload : Array[Rat]
  tags : Array[String]
}

pub(all) struct Paper {
  schema_name : String
  items : Array[Item]
  seed : Int
  request : String
}

pub(all) struct PaperFile {
  format : String
  schema_name : String
  title : String
  seed : Int
  items : Array[ItemFile]
}

pub struct Poly {
  coeffs : Array[Rat]
}

pub(all) struct Pool {
  items : Array[Item]
  attempted : Int
  rejected : Int
  duplicates : Int
  rejects : Array[String]
}

pub struct Rat {
  num : Int64
  den : Int64
}

pub struct Require {
  left : Expr
  op : CmpOp
  right : Expr
  line : Int
}

pub struct Rng {
  state : UInt64
}

pub(all) struct Schema {
  name : String
  family : Family
  title : String
  answers : Array[VarDecl]
  params : Array[VarDecl]
  requires : Array[Require]
  ask : String
  line : Int
}

pub(all) struct Slot {
  level : Int
  tags : Array[String]
  fingerprint : String
}

pub enum Tok {
  TIdent(String)
  TNum(Int64)
  TStr(String)
  TPunct(String)
  TBad(Char)
  TEof
}

pub struct Token {
  kind : Tok
  line : Int
}

pub struct VarDecl {
  name : String
  domain : (Int, Int)?
  expr : Expr?
  line : Int
}

pub enum Verdict {
  WellPosed
  NotQuadratic
  NoRealRoots
  DoubleRoot
  IrrationalRoots
  ExtraneousRoot
  Identity
  NotLinear
  AnswerMismatch(String)
}

pub(all) struct VerifyReport {
  total : Int
  passed : Int
  failures : Array[String]
}

fn assemble(pool : Pool, schema_name : String, bp : Blueprint) -> Result[Paper, String]

fn build_quadratic(schema : Schema, env : Map[String, Rat]) -> Result[Item, String]

fn build_rational(schema : Schema, env : Map[String, Rat]) -> Result[Item, String]

fn classify_quadratic(b : Rat, c : Rat, roots : Array[Rat]) -> (Int, Array[String])

fn classify_rational(r : Rat, k : Rat, q : Rat) -> (Int, Array[String])

fn escape_html(s : String) -> String

fn generate(schema : Schema, limit : Int) -> Pool

fn join_lines(lines : Array[String]) -> String

fn load_schema(src : String) -> Result[Schema, String]

fn paper_from_json_string(src : String) -> Result[PaperFile, String]

fn paper_to_json(paper : Paper, title : String) -> Json

fn paper_to_json_string(paper : Paper, title : String) -> String

fn parallel_form(pool : Pool, paper : Paper, seed : Int) -> Result[Paper, String]

fn parallel_paper_file(pool : Pool, pf : PaperFile, seed : Int) -> Result[Paper, String]

fn parse_int_opt(s : String) -> Int?

fn parse_rat(s : String) -> Rat?

fn quick_paper(schema_src : String, count : Int, seed : Int) -> Result[Paper, String]

fn quick_paper_with(schema_src : String, per_level : Array[(Int, Int)], seed : Int) -> Result[Paper, String]

fn rat(num : Int64, den : Int64) -> Rat

fn rat_int(n : Int64) -> Rat

fn rat_one() -> Rat

fn rat_zero() -> Rat

fn rebuild_quadratic(cert : Certificate) -> Poly

fn render_answer_key(paper : Paper, title : String) -> String

fn render_markdown(paper : Paper, title : String) -> String

fn render_worksheet(paper : Paper, title : String) -> String

fn replace_all(s : String, from : String, to : String) -> String

fn[T] shuffle(rng : Rng, xs : Array[T]) -> Unit

fn split_on(s : String, sep : Char) -> Array[String]

fn tokenize(src : String) -> Array[Token]

fn trim(s : String) -> String

fn verify_item_file(item : ItemFile) -> Verdict

fn verify_paper_file(pf : PaperFile) -> VerifyReport

fn verify_quadratic(p : Poly, declared : Array[Rat]) -> (Verdict, Certificate)

fn verify_rational(num : Poly, den : Poly, rhs : Rat, declared : Array[Rat]) -> (Verdict, Certificate)