pub(all) struct Aabb {
  min : Vec3
  max : Vec3
}

pub(all) struct Mesh {
  triangles : Array[Triangle]
}

pub(all) enum MeshFormat {
  Ascii
  Binary
  Obj
  ThreeMF
  Ply
  Unknown
}

pub(all) struct Obb {
  center : Vec3
  axes : Array[Vec3]
  half : Array[Double]
}

pub(all) struct PreviewOptions {
  width : Int
  height : Int
  yaw : Double
  pitch : Double
  stroke : String
  stroke_width : Double
}

pub(all) struct PrintabilityReport {
  validation : ValidationReport
  winding : WindingReport
  thickness : ThicknessReport?
  min_thickness : Double
}

pub(all) struct RayHit {
  distance : Double
  triangle : Int
  point : Vec3
}

pub(all) struct RepairOptions {
  tolerance : Double
  drop_degenerate : Bool
  drop_duplicates : Bool
  fill_holes : Bool
  recompute_normals : Bool
  unify_winding : Bool
}

pub(all) struct RepairResult {
  mesh : Mesh
  removed_degenerate : Int
  removed_duplicates : Int
  filled_holes : Int
  added_triangles : Int
  recomputed_normals : Int
  flipped_faces : Int
  reoriented_components : Int
}

pub(all) struct ScanStorage {
  unique_vertices : Int
  edge_records : Int
  pending_bytes : Int
  peak_buffered_bytes : Int
}

pub(all) struct StlScanner {
  // private fields
}

pub(all) struct StreamReport {
  triangle_count : Int
  raw_vertex_count : Int
  unique_vertex_count : Int
  boundary_edge_count : Int
  non_manifold_edge_count : Int
  volume : Double
  surface_area : Double
  bbox : Aabb?
}

pub(all) struct SymmetricEigen {
  values : FixedArray[Double]
  vectors : Array[Vec3]
}

pub(all) struct ThicknessReport {
  samples : Int
  hits : Int
  min_thickness : Double
  min_at : Vec3?
  mean_thickness : Double
}

pub(all) struct Triangle {
  normal : Vec3
  a : Vec3
  b : Vec3
  c : Vec3
}

pub(all) struct ValidationReport {
  triangle_count : Int
  raw_vertex_count : Int
  unique_vertex_count : Int
  boundary_edge_count : Int
  non_manifold_edge_count : Int
  degenerate_count : Int
  wrong_normal_count : Int
  unique_edge_count : Int
}

pub(all) struct Vec3 {
  x : Double
  y : Double
  z : Double
}

pub(all) struct WeldResult {
  ids : Array[Int]
  unique_count : Int
}

pub(all) struct WindingComponent {
  index : Int
  faces : Array[Int]
  flipped_faces : Int
  closed : Bool
  consistent : Bool
  signed_volume : Double
  orientation : WindingOrientation
  bounds : Aabb
  potentially_nested : Bool
}

pub(all) enum WindingOrientation {
  PositiveVolume
  NegativeVolume
  Indeterminate
} derive(Eq)

pub(all) struct WindingReport {
  flipped_faces : Int
  consistent : Bool
  signed_volume : Double
  components : Array[WindingComponent]
}

fn check_printability(mesh : Mesh, min_thickness : Double, samples? : Int) -> PrintabilityReport

fn check_thickness(mesh : Mesh, samples : Int) -> ThicknessReport

fn check_thickness_default(mesh : Mesh) -> ThicknessReport

fn check_winding(mesh : Mesh, tolerance : Double) -> WindingReport

fn check_winding_default(mesh : Mesh) -> WindingReport

fn count_parts(mesh : Mesh, tolerance : Double) -> Int

fn count_parts_default(mesh : Mesh) -> Int

fn default_weld_tolerance() -> Double

fn detect_format(data : Bytes) -> MeshFormat

fn is_3mf(data : Bytes) -> Bool

fn is_ply(data : Bytes) -> Bool

fn parse_3mf(data : Bytes) -> Result[Mesh, String]

fn parse_mesh(data : Bytes) -> Result[Mesh, String]

fn parse_obj(text : String) -> Result[Mesh, String]

fn parse_ply(data : Bytes, lenient_ascii? : Bool) -> Result[Mesh, String]

fn parse_stl(data : Bytes) -> Result[Mesh, String]

fn parse_stl_ascii(text : String) -> Result[Mesh, String]

fn parse_stl_binary(data : Bytes) -> Result[Mesh, String]

fn ray_triangle(origin : Vec3, dir : Vec3, a : Vec3, b : Vec3, c : Vec3) -> Double?

fn render_svg(mesh : Mesh, options : PreviewOptions) -> String

fn repair(mesh : Mesh, options : RepairOptions) -> RepairResult

fn review_scope() -> String

fn stream_stl_ascii(text : String) -> Result[StreamReport, String]

fn stream_stl_binary(data : Bytes) -> Result[StreamReport, String]

fn symmetric_eigendecomposition(m : FixedArray[Double]) -> SymmetricEigen

fn symmetric_eigenvalues(m : FixedArray[Double]) -> FixedArray[Double]

fn symmetric_eigenvector(m : FixedArray[Double], lambda : Double) -> Vec3

fn unify_winding(mesh : Mesh, tolerance : Double) -> Mesh

fn validate(mesh : Mesh, tolerance : Double) -> ValidationReport

fn validate_default(mesh : Mesh) -> ValidationReport

fn write_mesh(mesh : Mesh, path : String) -> Result[Bytes, String]

fn write_obj(mesh : Mesh) -> String

fn write_ply(mesh : Mesh) -> Bytes

fn write_ply_ascii(mesh : Mesh) -> String

fn write_ply_binary(mesh : Mesh) -> Bytes

fn write_stl_ascii(mesh : Mesh, name : String) -> String

fn write_stl_binary(mesh : Mesh) -> Bytes