// Generated by scripts/generate.mjs from bindings/api.mjs. Do not edit.

///|
#external
pub type MeshSelection

///|
#module("@mizchi/three-mbt/topology")
pub extern "js" fn MeshSelection::MeshSelection(
  topology : MeshTopology,
) -> MeshSelection = "meshSelection"

///|
pub extern "js" fn MeshSelection::topology(
  self : MeshSelection,
) -> MeshTopology =
  #| (self) => self.topology()

///|
extern "js" fn MeshSelection::ffi_set_vertex(
  self : MeshSelection,
  id : MeshVertexId,
  selected : Bool,
) -> JsResult[Unit] =
  #| (self, id, selected) => { try { return { ok: true, value: (() => self.setVertex(id, selected))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::set_vertex(
  self : MeshSelection,
  id : MeshVertexId,
  selected : Bool,
) -> Unit raise ModelingError {
  match self.ffi_set_vertex(id, selected).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}

///|
pub extern "js" fn MeshSelection::vertices(
  self : MeshSelection,
) -> FixedArray[MeshVertexId] =
  #| (self) => self.vertices()

///|
extern "js" fn MeshSelection::ffi_set_edge(
  self : MeshSelection,
  id : MeshEdgeId,
  selected : Bool,
) -> JsResult[Unit] =
  #| (self, id, selected) => { try { return { ok: true, value: (() => self.setEdge(id, selected))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::set_edge(
  self : MeshSelection,
  id : MeshEdgeId,
  selected : Bool,
) -> Unit raise ModelingError {
  match self.ffi_set_edge(id, selected).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}

///|
pub extern "js" fn MeshSelection::edges(
  self : MeshSelection,
) -> FixedArray[MeshEdgeId] =
  #| (self) => self.edges()

///|
extern "js" fn MeshSelection::ffi_set_face(
  self : MeshSelection,
  id : MeshFaceId,
  selected : Bool,
) -> JsResult[Unit] =
  #| (self, id, selected) => { try { return { ok: true, value: (() => self.setFace(id, selected))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::set_face(
  self : MeshSelection,
  id : MeshFaceId,
  selected : Bool,
) -> Unit raise ModelingError {
  match self.ffi_set_face(id, selected).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}

///|
pub extern "js" fn MeshSelection::faces(
  self : MeshSelection,
) -> FixedArray[MeshFaceId] =
  #| (self) => self.faces()

///|
pub extern "js" fn MeshSelection::clear(self : MeshSelection) -> Unit =
  #| (self) => self.clear()

///|
pub extern "js" fn MeshSelection::effective_vertices(
  self : MeshSelection,
) -> FixedArray[MeshVertexId] =
  #| (self) => self.effectiveVertices()

///|
pub extern "js" fn MeshSelection::grow_vertices(self : MeshSelection) -> Unit =
  #| (self) => self.growVertices()

///|
extern "js" fn MeshSelection::ffi_select_connected_faces(
  self : MeshSelection,
  face : MeshFaceId,
) -> JsResult[Unit] =
  #| (self, face) => { try { return { ok: true, value: (() => self.selectConnectedFaces(face))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::select_connected_faces(
  self : MeshSelection,
  face : MeshFaceId,
) -> Unit raise ModelingError {
  match self.ffi_select_connected_faces(face).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}

///|
extern "js" fn MeshSelection::ffi_translated_geometry(
  self : MeshSelection,
  offset : Vector3,
) -> JsResult[BufferGeometry] =
  #| (self, offset) => { try { return { ok: true, value: (() => self.translatedGeometry(offset))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::translated_geometry(
  self : MeshSelection,
  offset : Vector3,
) -> BufferGeometry raise ModelingError {
  match self.ffi_translated_geometry(offset).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}

///|
extern "js" fn MeshSelection::ffi_transformed_geometry(
  self : MeshSelection,
  matrix : Matrix4,
) -> JsResult[BufferGeometry] =
  #| (self, matrix) => { try { return { ok: true, value: (() => self.transformedGeometry(matrix))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::transformed_geometry(
  self : MeshSelection,
  matrix : Matrix4,
) -> BufferGeometry raise ModelingError {
  match self.ffi_transformed_geometry(matrix).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}

///|
extern "js" fn MeshSelection::ffi_extruded_geometry(
  self : MeshSelection,
  offset : Vector3,
  side_material : Int,
) -> JsResult[BufferGeometry] =
  #| (self, offset, side_material) => { try { return { ok: true, value: (() => self.extrudedGeometry(offset, side_material))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::extruded_geometry(
  self : MeshSelection,
  offset : Vector3,
  side_material : Int,
) -> BufferGeometry raise ModelingError {
  match self.ffi_extruded_geometry(offset, side_material).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}

///|
extern "js" fn MeshSelection::ffi_split_edges_geometry(
  self : MeshSelection,
  fraction : Double,
) -> JsResult[BufferGeometry] =
  #| (self, fraction) => { try { return { ok: true, value: (() => self.splitEdgesGeometry(fraction))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::split_edges_geometry(
  self : MeshSelection,
  fraction : Double,
) -> BufferGeometry raise ModelingError {
  match self.ffi_split_edges_geometry(fraction).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}

///|
extern "js" fn MeshSelection::ffi_beveled_geometry(
  self : MeshSelection,
  width : Double,
  bevel_material : Int,
) -> JsResult[BufferGeometry] =
  #| (self, width, bevel_material) => { try { return { ok: true, value: (() => self.beveledGeometry(width, bevel_material))() }; } catch (error) { return { ok: false, error: String(error) }; } }

///|
pub fn MeshSelection::beveled_geometry(
  self : MeshSelection,
  width : Double,
  bevel_material : Int,
) -> BufferGeometry raise ModelingError {
  match self.ffi_beveled_geometry(width, bevel_material).into_result() {
    Ok(value) => value
    Err(message) => raise ModelingError(message)
  }
}