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

pub(all) struct Face3 {
  a : Int
  b : Int
  c : Int
}

pub struct IndexedMesh {
  // private fields
}

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) enum ParseError {
  InvalidLimits(String)
  ResourceLimitExceeded(String)
  UnknownFormat(String)
  InvalidData(MeshFormat, String)
}

pub(all) struct ParseLimits {
  max_input_bytes : Int
  max_vertices : Int
  max_triangles : Int
  max_list_items : Int
  max_polygon_vertices : Int
  max_uncompressed_bytes : Int
  max_zip_entries : Int
  max_component_depth : Int
  max_component_instances : Int
  max_records : Int
  max_line_bytes : Int
  max_xml_depth : Int
}

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 RepairLimits {
  max_faces : Int
  max_boundary_edges : Int
  max_hole_vertices : Int
  max_holes : Int
}

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_area_weighted(mesh : Mesh, samples : Int, seed? : 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 inspection_json(mesh : Mesh, format? : MeshFormat, min_thickness? : Double, samples? : Int) -> Result[Json, String]

fn is_3mf(data : Bytes) -> Bool

fn is_ply(data : Bytes) -> Bool

fn parse_3mf(data : Bytes, compatibility? : Bool, limits? : ParseLimits) -> Result[Mesh, String]

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

fn parse_mesh_checked(data : Bytes, limits? : ParseLimits) -> Result[Mesh, ParseError]

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

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

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

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

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

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