@meshinspector/meshlib 3.1.3-337 → 3.1.4-297

package/bindings.d.mts

@@ -34,19 +34,40 @@ export interface ClassHandle {
   [Symbol.dispose](): void;
   clone(): this;
 }
+export interface NoiseSettings extends ClassHandle {
+  sigma: number;
+  seed: number;
+}
+
 export interface AffineXf3f extends ClassHandle {
   A: Matrix3f;
   b: Vector3f;
-  mul(_0: AffineXf3f): AffineXf3f;
-  apply(_0: Vector3f): Vector3f;
+  mul(b: AffineXf3f): AffineXf3f;
+  apply(v: Vector3f): Vector3f;
 }
 
+/**
+ * std::vector<bool> like container (random-access, size_t - index type, bool - value type) with all bits after size() considered off during testing
+ */
 export interface BitSet extends ClassHandle {
   size(): number;
+  /**
+   * @brief computes the number of set bits in the whole set
+   */
   count(): number;
   empty(): boolean;
-  test(_0: number): boolean;
-  toIndices(): any;
+  test(n: number): boolean;
+  set(n: number, val: boolean): void;
+  resize(numBits: number, fillValue: boolean): void;
+  /**
+   * @brief return the smallest index i such that bit i is set, or npos if *this has no on bits.
+   */
+  find_first(): number;
+  /**
+   * @brief return the highest index i such that bit i is set, or npos if *this has no on bits.
+   */
+  find_last(): number;
+  toIndices(): Uint32Array;
 }
 
 export interface FaceBitSet extends BitSet {
@@ -79,6 +100,25 @@ export interface Box3i extends ClassHandle {
   size(): Vector3i;
 }
 
+export interface DistanceFromWeightedPointsParams extends ClassHandle {
+  /**
+   * minimal weight among all points in the cloud; if this value is imprecise, then more computations will be made by algorithm
+   */
+  minWeight: number;
+  /**
+   * maximal weight among all points in the cloud; if this value is imprecise, then more computations will be made by algorithm
+   */
+  maxWeight: number;
+  /**
+   * maximal magnitude of gradient of points' weight in the cloud, >=0; if maxWeightGrad < 1 then more search optimizations can be done
+   */
+  maxWeightGrad: number;
+  /**
+   * for points, it must always true; for triangles: if true the distances grow in both directions from each triangle, reaching minimum in the triangle; if false the distances grow to infinity in the direction of triangle's normals, and decrease to minus infinity in the opposite direction
+   */
+  bidirectionalMode: boolean;
+}
+
 export type Color = {
   r: number,
   g: number,
@@ -86,33 +126,72 @@ export type Color = {
   a: number
 };
 
+/**
+ * This structure contains result of MR::cutMesh function
+ */
+type CutMeshResult = {
+  /**
+   * @brief Paths of new edges on mesh, they represent same contours as input, but already cut.
+   */
+  resultCut: Uint32Array[];
+  /**
+   * Bitset of bad triangles - triangles where input contours have intersections and cannot be cut and filled in a good way @see MR::CutMeshParameters
+   */
+  fbsWithContourIntersections: FaceBitSet;
+};
+
 export interface FillPartValue<T extends number> {
   value: T;
 }
+/**
+ * Caller can avoid filling non-needed part of cut faces to speedup cutting still add pseudo FaceId to opposite side to keep connectivity
+ */
 export type FillPart = FillPartValue<0>|FillPartValue<1>|FillPartValue<2>;
 
 export interface ForceFillValue<T extends number> {
   value: T;
 }
+/**
+ * This enum defines the MR::cutMesh behaviour in case of bad faces acure basicaly MR::cutMesh removes all faces which contours pass through, adds new edges to topology and fills all removed parts
+ *
+ * @note Bad faces here mean faces where contours have intersections and cannot be cut and filled in an good way
+ */
 export type ForceFill = ForceFillValue<0>|ForceFillValue<1>|ForceFillValue<2>;
 
+/**
+ * @brief Parameters of MR::cutMesh.
+ *
+ * This structure contains some options and optional outputs of MR::cutMesh function @see MR::CutMeshResult
+ */
 export interface CutMeshParameters extends ClassHandle {
   fillPart: FillPart;
   forceFillMode: ForceFill;
 }
 
+/**
+ * @brief Settings structurer for cutMeshByProjection function.
+ */
 export interface CutByProjectionSettings extends ClassHandle {
+  /**
+   * @brief direction of projection (in mesh space)
+   */
   direction: Vector3f;
 }
 
 export interface EdgeWeightsValue<T extends number> {
   value: T;
 }
+/**
+ * @brief determines the weight of each edge in applications like Laplacian
+ */
 export type EdgeWeights = EdgeWeightsValue<0>|EdgeWeightsValue<1>;
 
 export interface VertexMassValue<T extends number> {
   value: T;
 }
+/**
+ * @brief determines the weight or mass of each vertex in applications like Laplacian
+ */
 export type VertexMass = VertexMassValue<0>|VertexMassValue<1>;
 
 export interface RememberShapeValue<T extends number> {
@@ -125,64 +204,138 @@ export interface OffsetModeValue<T extends number> {
 }
 export type OffsetMode = OffsetModeValue<0>|OffsetModeValue<1>|OffsetModeValue<2>;
 
+/**
+ * @brief a pair of faces
+ */
+type FaceFace = { aFace: number; bFace: number };
+
 export interface SubdivideFillingSettings extends ClassHandle {
+  /**
+   * @brief Subdivision is stopped when all edges inside or on the boundary of the region are not longer than this value.
+   */
   maxEdgeLen: number;
+  /**
+   * @brief Maximum number of edge splits allowed during subdivision.
+   */
   maxEdgeSplits: number;
+  /**
+   * @brief Improves local mesh triangulation by doing edge flips if it does not change dihedral angle more than on this value (in radians)
+   */
   maxAngleChangeAfterFlip: number;
 }
 
 export interface SmoothFillingSettings extends ClassHandle {
+  /**
+   * @brief Additionally smooth 3 layers of vertices near hole boundary both inside and outside of the hole.
+   */
   naturalSmooth: boolean;
+  /**
+   * @brief edge weighting scheme for smoothCurvature mode
+   */
   edgeWeights: EdgeWeights;
+  /**
+   * @brief vertex mass scheme for smoothCurvature mode
+   */
   vmass: VertexMass;
 }
 
 export interface FillHoleNicelySettings extends ClassHandle {
+  /**
+   * @brief If false then additional vertices are created inside the patch for best mesh quality.
+   */
   triangulateOnly: boolean;
+  /**
+   * @brief if `triangulateOnly` is false - this settings are used to subdivide new filling
+   */
   subdivideSettings: SubdivideFillingSettings;
+  /**
+   * @brief Whether to make patch over the hole smooth both inside and on its boundary with existed surface.
+   */
   smoothCurvature: boolean;
+  /**
+   * @brief if `smoothCurvature` is true and `triangulateOnly is false - these settings are used to smooth new filling
+   */
   smoothSettings: SmoothFillingSettings;
+  /**
+   * @brief how to triangulate the hole, must be specified by the user
+   */
   triangulateParams: FillHoleParams;
 }
 
 export interface SelfIntersectionsMethodValue<T extends number> {
   value: T;
 }
+/**
+ * @brief Fix method.
+ */
 export type SelfIntersectionsMethod = SelfIntersectionsMethodValue<0>|SelfIntersectionsMethodValue<1>;
 
+/**
+ * @brief Setting set for mesh self-intersections fix.
+ */
 export interface SelfIntersectionsSettings extends ClassHandle {
+  /**
+   * @brief If true then count touching faces as self-intersections.
+   */
   touchIsIntersection: boolean;
   method: SelfIntersectionsMethod;
+  /**
+   * @brief Maximum relax iterations.
+   */
   relaxIterations: number;
+  /**
+   * @brief Maximum expand count (edge steps from self-intersecting faces), should be >= 0.
+   */
   maxExpand: number;
+  /**
+   * Edge length for subdivision of holes covers (0.0f means auto) FLT_MAX to disable subdivision
+   */
   subdivideEdgeLen: number;
+  /**
+   * @brief trying to stay close to initial surface when patching
+   */
   mimicPatch: boolean;
-  callback: any;
+  /**
+   * @brief Callback function.
+   */
+  callback: ( progress: number ) => boolean;
 }
 
 export interface SelfIntersections extends ClassHandle {
 }
 
+/**
+ * @brief wrapper class that helps mrbind to avoid excess MRVDBFloatGrid.h includes
+ */
 export interface FloatGrid extends ClassHandle {
 }
 
+/**
+ * @brief Class for deforming mesh using Bernstein interpolation.
+ */
 export interface FreeFormDeformer extends ClassHandle {
   init(): void;
   apply(): void;
-  init(_0: Vector3i): void;
-  init(_0: Vector3i, _1: Box3f): void;
-  setRefGridPointPosition(_0: Vector3i, _1: Vector3f): void;
-  getRefGridPointPosition(_0: Vector3i): Vector3f;
+  init(resolution: Vector3i): void;
+  init(resolution: Vector3i, initialBox: Box3f): void;
+  setRefGridPointPosition(coordOfPointInGrid: Vector3i, newPos: Vector3f): void;
+  getRefGridPointPosition(coordOfPointInGrid: Vector3i): Vector3f;
 }
 
 export interface ICPMethodValue<T extends number> {
   value: T;
 }
+/**
+ * @brief The method how to update transformation from point pairs.
+ */
 export type ICPMethod = ICPMethodValue<0>|ICPMethodValue<1>|ICPMethodValue<2>;
 
 export interface ICPModeValue<T extends number> {
   value: T;
 }
+/**
+ * @brief The group of transformations, each with its own degrees of freedom.
+ */
 export type ICPMode = ICPModeValue<0>|ICPModeValue<1>|ICPModeValue<2>|ICPModeValue<3>|ICPModeValue<4>;
 
 export interface ICPExitTypeValue<T extends number> {
@@ -190,44 +343,140 @@ export interface ICPExitTypeValue<T extends number> {
 }
 export type ICPExitType = ICPExitTypeValue<0>|ICPExitTypeValue<1>|ICPExitTypeValue<2>|ICPExitTypeValue<3>|ICPExitTypeValue<4>;
 
+/**
+ * @brief parameters of ICP algorithm
+ */
 export interface ICPProperties extends ClassHandle {
+  /**
+   * @brief The method how to update transformation from point pairs, see description of each option in ICPMethod.
+   */
   method: ICPMethod;
+  /**
+   * Rotation angle during one iteration of ICPMethod::PointToPlane will be limited by this value. This is to reduce possible instability.
+   */
   p2plAngleLimit: number;
+  /**
+   * Scaling during one iteration of ICPMethod::PointToPlane will be limited by this value. This is to reduce possible instability.
+   */
   p2plScaleLimit: number;
+  /**
+   * If source and target points in a pair both have normals, then dot-product of normals must be not smaller than (cosThreshold), otherwise such point pair will be deactivated (ignored) during transformation computation. This is to get rid of erroneous pairs on unrelated parts of objects, which are close only by chance.
+   */
   cosThreshold: number;
+  /**
+   * The squared distance between source and target points in a pair must be not greater than (distThresholdSq), otherwise such point pair will be deactivated (ignored) during transformation computation. This is to get rid of outliers in input objects.
+   */
   distThresholdSq: number;
+  /**
+   * First, root-mean-square distance between points in all active pairs is computed as D. Then, the distance between source and target points in a pair must be not greater than (farDistFactor * D), otherwise such point pair will be deactivated (ignored) during transformation computation. This is to progressively reduce the distance threshold as the algorithm converge to a solution.
+   */
   farDistFactor: number;
+  /**
+   * Selects the group of transformations, where to find a solution (e.g. with scaling or without, with rotation or without, ...). See the description of each option in ICPMode.
+   */
   icpMode: ICPMode;
+  /**
+   * The maximum number of iterations that the algorithm can perform. Increase this parameter if you need a higher precision or if initial approximation is not very precise.
+   */
   iterLimit: number;
+  /**
+   * The algorithm will stop before making all (iterLimit) iterations, if there were consecutive (badIterStopCount) iterations, during which the average distance between points in active pairs did not diminish.
+   */
   badIterStopCount: number;
+  /**
+   * The algorithm will stop before making all (iterLimit) iterations, if the average distance between points in active pairs became smaller than this value.
+   */
   exitVal: number;
+  /**
+   * A pair of points is activated only if both points in the pair are mutually closest (reciprocity test passed), some papers recommend this mode for filtering out wrong pairs, but it can be too aggressive and deactivate (almost) all pairs.
+   */
   mutualClosest: boolean;
+  /**
+   * @brief if this flag is true and a source point finds its correspondence on a boundary of target object, then ignores such pair
+   */
   ignoreBdTgts: boolean;
+  /**
+   * @brief Additional parameter for ICPMode::OrthogonalAxis and ICPMode::FixedAxis transformation groups.
+   */
   fixedRotationAxis: Vector3f;
 }
 
+/**
+ * This class allows you to register two object with similar shape using Iterative Closest Points (ICP) point-to-point or point-to-plane algorithms
+ */
 export interface ICP extends ClassHandle {
-  setParams(_0: ICPProperties): void;
-  samplePoints(_0: number): void;
+  /**
+   * @brief tune algorithm params before run calculateTransformation()
+   */
+  setParams(prop: ICPProperties): void;
+  /**
+   * @brief select pairs with origin samples on both objects
+   */
+  samplePoints(samplingVoxelSize: number): void;
+  /**
+   * automatically selects initial transformation for the floating object based on covariance matrices of both floating and reference objects; applies the transformation to the floating object and returns it
+   */
   autoSelectFloatXf(): AffineXf3f;
+  /**
+   * @brief recompute point pairs after manual change of transformations or parameters
+   */
   updatePointPairs(): void;
   getStatusInfo(): string;
+  /**
+   * @brief computes the number of samples able to form pairs
+   */
   getNumSamples(): number;
+  /**
+   * @brief computes the number of active point pairs
+   */
   getNumActivePairs(): number;
+  /**
+   * @brief computes root-mean-square deviation between points
+   */
   getMeanSqDistToPoint(): number;
+  /**
+   * @brief computes root-mean-square deviation from points to target planes
+   */
   getMeanSqDistToPlane(): number;
+  /**
+   * runs ICP algorithm given input objects, transformations, and parameters; @returns adjusted transformation of the floating object to match reference object
+   */
   calculateTransformation(): AffineXf3f;
 }
 
 export interface ContinuousContours extends ClassHandle {
 }
 
+/**
+ * Laplacian to smoothly deform a region preserving mesh fine details. How to use:
+ * 1. Initialize Laplacian for the region being deformed, here region properties are remembered.
+ * 2. Change positions of some vertices within the region and call fixVertex for them.
+ * 3. Optionally call updateSolver()
+ * 4. Call apply() to change the remaining vertices within the region Then steps 1-4 or 2-4 can be repeated.
+ */
 export interface Laplacian extends ClassHandle {
-  init(_0: VertBitSet, _1: EdgeWeights): void;
-  init(_0: VertBitSet, _1: EdgeWeights, _2: VertexMass, _3: RememberShape): void;
-  fixVertex(_0: number, _1: boolean): void;
+  /**
+   * (re)initialize Laplacian for the region being deformed, here region properties are remembered and precomputed; @param freeVerts must not include all vertices of a mesh connected component;
+   * @param usePoints is not nullptr, then these points will be used instead of passed to a constructor for weights computation and shape memory
+   */
+  init(freeVerts: VertBitSet, weights: EdgeWeights): void;
+  /**
+   * (re)initialize Laplacian for the region being deformed, here region properties are remembered and precomputed; @param freeVerts must not include all vertices of a mesh connected component;
+   * @param usePoints is not nullptr, then these points will be used instead of passed to a constructor for weights computation and shape memory
+   */
+  init(freeVerts: VertBitSet, weights: EdgeWeights, vmass: VertexMass, rem: RememberShape): void;
+  /**
+   * notify Laplacian that given vertex has changed after init and must be fixed during apply; @param smooth whether to make the surface smooth in this vertex (sharp otherwise)
+   */
+  fixVertex(v: number, smooth: boolean): void;
+  /**
+   * takes fixed vertex positions from the points vector passed to a constructor, computes and writes free vertex positions in the points vector passed to a constructor as well
+   */
   apply(): void;
-  fixVertex(_0: number, _1: Vector3f, _2: boolean): void;
+  /**
+   * notify Laplacian that given vertex has changed after init and must be fixed during apply; @param smooth whether to make the surface smooth in this vertex (sharp otherwise)
+   */
+  fixVertex(v: number, fixedPos: Vector3f, smooth: boolean): void;
 }
 
 export type SphereParams = {
@@ -241,59 +490,189 @@ export interface Matrix3f extends ClassHandle {
   z: Vector3f;
 }
 
+/**
+ * This class represents a mesh, including topology (connectivity) information and point coordinates, as well as some caches to accelerate search algorithms
+ */
 export interface Mesh extends ClassHandle {
   readonly topology: MeshTopology;
-  readonly points: VertCoords;
+  points: VertCoords;
+  /**
+   * @brief tightly packs all arrays eliminating lone edges and invalid faces, vertices and points
+   */
   pack(): void;
+  /**
+   * packs tightly and rearranges vertices, triangles and edges to put close in space elements in close indices @param preserveAABBTree whether to keep valid mesh's AABB tree after return (it will take longer to compute and it will occupy more memory)
+   */
+  packOptimally(): void;
+  /**
+   * returns volume of the object surrounded by given region (or whole mesh if (region) is nullptr); if the region has holes then each hole will be virtually filled by adding triangles for each edge and the hole's geometrical center
+   */
   volume(): number;
+  /**
+   * @brief returns the area of given face
+   */
   area(): number;
+  /**
+   * passes through all valid vertices and finds the minimal bounding box containing all of them; if toWorld transformation is given then returns minimal bounding box in world space
+   */
   computeBoundingBox(): Box3f;
+  /**
+   * invalidates caches (aabb-trees) after any change in mesh geometry or topology @param pointsChanged specifies whether points have changed (otherwise only topology has changed)
+   */
   invalidateCaches(): void;
-  transform(_0: AffineXf3f): void;
+  /**
+   * applies given transformation to specified vertices if region is nullptr, all valid mesh vertices are used
+   */
+  transform(xf: AffineXf3f): void;
+  /**
+   * @brief computes average length of an edge in this mesh
+   */
   averageEdgeLength(): number;
-  addMesh(_0: Mesh | null): void;
-  edgeLength(_0: number): number;
-  edgeLengthSq(_0: number): number;
+  /**
+   * @brief appends another mesh as separate connected component(s) to this
+   */
+  addMesh(from: Mesh | null): void;
+  /**
+   * @brief returns Euclidean length of the edge
+   */
+  edgeLength(e: number): number;
+  /**
+   * @brief returns squared Euclidean length of the edge (faster to compute than length)
+   */
+  edgeLengthSq(e: number): number;
+  /**
+   * @brief computes triangular face normal from its vertices
+   */
+  normal(v: number): Vector3f;
+  /**
+   * @brief computes average position of all valid mesh vertices
+   */
   findCenterFromPoints(): Vector3f;
+  /**
+   * @brief computes center of mass considering that density of all triangles is the same
+   */
   findCenterFromFaces(): Vector3f;
+  /**
+   * @brief computes bounding box and returns its center
+   */
   findCenterFromBBox(): Vector3f;
-  toTriPoint(_0: number, _1: Vector3f): any;
+  /**
+   * @brief converts vertex into barycentric representation
+   */
+  toTriPoint(f: number, p: Vector3f): MeshTriPoint;
 }
 
 export interface BooleanOperationValue<T extends number> {
   value: T;
 }
+/**
+ * Enum class of available CSG operations
+ * @see MR::boolean
+ */
 export type BooleanOperation = BooleanOperationValue<0>|BooleanOperationValue<1>|BooleanOperationValue<2>|BooleanOperationValue<3>|BooleanOperationValue<4>|BooleanOperationValue<5>|BooleanOperationValue<6>|BooleanOperationValue<7>;
 
+/**
+ * @brief Structure contain boolean result.
+ *
+ * Structure with parameters for boolean call.
+ *
+ * This structure store result mesh of MR::boolean or some error info
+ */
 export interface BooleanResult extends ClassHandle {
+  /**
+   * @brief Holds error message, empty if boolean succeed.
+   */
   get errorString(): string;
   set errorString(value: EmbindString);
+  /**
+   * @brief Result mesh of boolean operation, if error occurred it would be empty.
+   */
   readonly mesh: Mesh | null;
+  /**
+   * @brief Returns true if boolean succeed, false otherwise.
+   */
   valid(): boolean;
 }
 
 export interface BooleanMapObjectValue<T extends number> {
   value: T;
 }
+/**
+ * @brief Input object index enum.
+ */
 export type BooleanMapObject = BooleanMapObjectValue<0>|BooleanMapObjectValue<1>;
 
+/**
+ * @brief Structure to map old mesh BitSets to new.
+ *
+ * Structure to easily map topology of MR::boolean input meshes to result mesh
+ *
+ * This structure allows to map faces, vertices and edges of mesh `A` and mesh `B` input of MR::boolean to result mesh topology primitives @see MR::boolean
+ */
 export interface BooleanResultMapper extends ClassHandle {
-  mapFaces(_0: FaceBitSet, _1: BooleanMapObject): FaceBitSet;
-  mapVerts(_0: VertBitSet, _1: BooleanMapObject): VertBitSet;
+  mapFaces(oldBS: FaceBitSet, obj: BooleanMapObject): FaceBitSet;
+  mapVerts(oldBS: VertBitSet, obj: BooleanMapObject): VertBitSet;
+  /**
+   * @brief Returns only new faces that are created during boolean operation.
+   */
   newFaces(): FaceBitSet;
-  filteredOldFaceBitSet(_0: FaceBitSet, _1: BooleanMapObject): FaceBitSet;
-  getNew2OldFaceMap(_0: BooleanMapObject): FaceMap;
+  /**
+   * @brief returns updated oldBS leaving only faces that has corresponding ones in result mesh
+   */
+  filteredOldFaceBitSet(oldBS: FaceBitSet, obj: BooleanMapObject): FaceBitSet;
+  /**
+   * @brief returns map: new_face_id->old_obj_face_id for faces from
+   *
+   * @param obj
+   */
+  getNew2OldFaceMap(obj: BooleanMapObject): FaceMap;
+}
+
+/**
+ * @brief Building topologies by triangles.
+ *
+ * This namespace provides API for building meshes.
+ *
+ * Simple example with key steps
+ *
+ * @warning Vertices of triangles should have consistent bypass direction
+ *
+ * @note It is better to store topology directly in mesh
+ *
+ * @see MeshTopology
+ */
+export interface MeshBuilder extends ClassHandle {
 }
 
-export interface MeshBuilder extends ClassHandle {
+type CollidingTriangleBitsets = { a: FaceBitSet; b: FaceBitSet };
+
+/**
+ * if isEdgeATriB() == true, then stores edge from mesh A and triangle from mesh B if isEdgeATriB() == false, then stores edge from mesh B and triangle from mesh A
+ */
+export interface VarEdgeTri extends ClassHandle {
+  readonly edge: number;
+  tri(): number;
+  isEdgeATriB(): boolean;
 }
 
+/**
+ * In each VarEdgeTri = pair of (intersected edge, intersected triangle), the intersected edge is directed from negative half-space of the intersected triangle B to its positive half-space
+ */
 export interface PreciseCollisionResult extends ClassHandle {
+  size(): number;
+  get(i: number): VarEdgeTri;
 }
 
+type ComponentsMapResult = { map: Face2RegionMap; numRegions: number };
+
+type LargeByAreaRegionsResult = { faces: FaceBitSet; numRegions: number };
+
 export interface MeshComponentsFaceIncidenceValue<T extends number> {
   value: T;
 }
+/**
+ * @brief Face incidence type.
+ */
 export type MeshComponentsFaceIncidence = MeshComponentsFaceIncidenceValue<0>|MeshComponentsFaceIncidenceValue<1>;
 
 export interface MeshComponents extends ClassHandle {
@@ -302,8 +681,20 @@ export interface MeshComponents extends ClassHandle {
 export interface DecimateStrategyValue<T extends number> {
   value: T;
 }
+/**
+ * @brief Defines the order of edge collapses inside Decimate algorithm.
+ */
 export type DecimateStrategy = DecimateStrategyValue<0>|DecimateStrategyValue<1>;
 
+/**
+ * @brief Results of MR::decimateMesh.
+ *
+ * @see decimateMesh
+ *
+ * @see decimateParallelMesh
+ *
+ * @see resolveMeshDegenerations
+ */
 export type DecimateResult = {
   vertsDeleted: number,
   facesDeleted: number,
@@ -311,53 +702,194 @@ export type DecimateResult = {
   cancelled: boolean
 };
 
+/**
+ * @brief Parameters structure for MR::decimateMesh.
+ *
+ * @see decimateMesh
+ */
 export interface DecimateSettings extends ClassHandle {
   strategy: DecimateStrategy;
+  /**
+   * for DecimateStrategy::MinimizeError: stop the decimation as soon as the estimated distance deviation from the original mesh is more than this value for DecimateStrategy::ShortestEdgeFirst only: stop the decimation as soon as the shortest edge in the mesh is greater than this value
+   */
   maxError: number;
+  /**
+   * @brief Maximal possible edge length created during decimation.
+   */
   maxEdgeLen: number;
+  /**
+   * @brief Maximal shift of a boundary during one edge collapse.
+   */
   maxBdShift: number;
+  /**
+   * @brief Maximal possible aspect ratio of a triangle introduced during decimation.
+   */
   maxTriangleAspectRatio: number;
+  /**
+   * the algorithm will ignore dihedral angle check if one of triangles had aspect ratio equal or more than this value; and the algorithm will permit temporary increase in aspect ratio after collapse, if before collapse one of the triangles had larger aspect ratio
+   */
   criticalTriAspectRatio: number;
+  /**
+   * @brief edges not longer than this value will be collapsed even if it results in appearance of a triangle with high aspect ratio
+   */
   tinyEdgeLength: number;
+  /**
+   * Small stabilizer is important to achieve good results on completely planar mesh parts, if your mesh is not-planer everywhere, then you can set it to zero
+   */
   stabilizer: number;
+  /**
+   * if false, then quadratic error metric is equal to the sum of distances to the planes of original mesh triangles; if true, then the sum is weighted, and the weight is equal to the angle of adjacent triangle at the vertex divided on PI (to get one after summing all 3 vertices of the triangle)
+   */
   angleWeightedDistToPlane: boolean;
+  /**
+   * if true then after each edge collapse the position of remaining vertex is optimized to minimize local shape change, if false then the edge is collapsed in one of its vertices, which keeps its position
+   */
   optimizeVertexPos: boolean;
+  /**
+   * @brief Limit on the number of deleted vertices.
+   */
   maxDeletedVertices: number;
+  /**
+   * @brief Limit on the number of deleted faces.
+   */
   maxDeletedFaces: number;
+  /**
+   * Whether to allow collapse of edges incident to notFlippable edges, which can move vertices of notFlippable edges unless they are fixed
+   */
   collapseNearNotFlippable: boolean;
+  /**
+   * @brief Whether to allow collapsing or flipping edges having at least one vertex on (region) boundary.
+   */
   touchNearBdEdges: boolean;
+  /**
+   * touchBdVerts=true: allow moving and eliminating boundary vertices during edge collapses; touchBdVerts=false: allow only collapsing an edge having only one boundary vertex in that vertex, so position and count of boundary vertices do not change; this setting is ignored if touchNearBdEdges=false
+   */
   touchBdVerts: boolean;
+  /**
+   * Permit edge flips (in addition to collapsing) to improve Delone quality of the mesh if it does not change dihedral angle more than on this value (negative value prohibits any edge flips)
+   */
   maxAngleChange: number;
+  /**
+   * @brief whether to pack mesh at the end
+   */
   packMesh: boolean;
+  /**
+   * If this value is more than 1, then virtually subdivides the mesh on given number of parts to process them in parallel (using many threads); IMPORTANT: please call mesh.packOptimally() before calling decimating with subdivideParts > 1, otherwise performance will be bad
+   */
   subdivideParts: number;
+  /**
+   * After parallel decimation of all mesh parts is done, whether to perform final decimation of whole mesh region to eliminate small edges near the border of individual parts
+   */
   decimateBetweenParts: boolean;
+  /**
+   * @brief minimum number of faces in one subdivision part for ( subdivideParts > 1 ) mode
+   */
   minFacesInPart: number;
 }
 
 export interface RemeshSettings extends ClassHandle {
+  /**
+   * the algorithm will try to keep the length of all edges close to this value, splitting the edges longer than targetEdgeLen, and then eliminating the edges shorter than targetEdgeLen
+   */
   targetEdgeLen: number;
+  /**
+   * @brief Maximum number of edge splits allowed during subdivision.
+   */
   maxEdgeSplits: number;
+  /**
+   * @brief Improves local mesh triangulation by doing edge flips if it does not change dihedral angle more than on this value.
+   */
   maxAngleChangeAfterFlip: number;
+  /**
+   * Allows or prohibits splitting and/or collapse boundary edges it recommended to keep default value here for better quality
+   */
   frozenBoundary: boolean;
+  /**
+   * Maximal shift of a boundary during one edge collapse only makes sense if `frozenBoundary=false`
+   */
   maxBdShift: number;
+  /**
+   * This option in subdivision works best for natural surfaces, where all triangles are close to equilateral and have similar area, and no sharp edges in between
+   */
   useCurvature: boolean;
+  /**
+   * An edge is subdivided only if both its left and right triangles have aspect ratio below or equal to this value. So this is a maximum aspect ratio of a triangle that can be split on two before Delone optimization. Please set it to a smaller value only if frozenBoundary==true, otherwise many narrow triangles can appear near border
+   */
   maxSplittableTriAspectRatio: number;
+  /**
+   * the number of iterations of final relaxation of mesh vertices; few iterations can give almost perfect uniformity of the vertices and edge lengths but deviate from the original surface
+   */
   finalRelaxIters: number;
+  /**
+   * @brief if true prevents the surface from shrinkage after many iterations
+   */
   finalRelaxNoShrinkage: boolean;
+  /**
+   * @brief whether to pack mesh at the end
+   */
   packMesh: boolean;
+  /**
+   * if true, then every new vertex after subdivision will be projected on the original mesh (before smoothing); this does not affect the vertices moved on other stages of the processing
+   */
   projectOnOriginalMesh: boolean;
 }
 
 export interface MultipleEdgesResolveModeValue<T extends number> {
   value: T;
 }
+/**
+ * If Strong makes additional efforts to avoid creating multiple edges, in some rare cases it is not possible (cases with extremely bad topology), if you faced one try to use MR::duplicateMultiHoleVertices before MR::fillHole
+ *
+ * If Simple avoid creating edges that already exist in topology (default)
+ *
+ * If None do not avoid multiple edges
+ */
 export type MultipleEdgesResolveMode = MultipleEdgesResolveModeValue<0>|MultipleEdgesResolveModeValue<1>|MultipleEdgesResolveModeValue<2>;
 
+/**
+ * @brief Parameters structure for MR::fillHole
+ * Structure has some options to control MR::fillHole.
+ *
+ * @see fillHole
+ *
+ * @see FillHoleMetric
+ */
 export interface FillHoleParams extends ClassHandle {
+  /**
+   * If true, hole filling will minimize the sum of metrics including boundary edges, where one triangle was present before hole filling, and another is added during hole filling. This makes boundary edges same smooth as inner edges of the patch. If false, edge metric will not be applied to boundary edges, and the patch tends to make a sharper turn there.
+   */
   smoothBd: boolean;
   multipleEdgesResolveMode: MultipleEdgesResolveMode;
+  /**
+   * If true creates degenerate faces band around hole to have sharp angle visualization @warning This flag bad for result topology, most likely you do not need it
+   */
   makeDegenerateBand: boolean;
+  /**
+   * The maximum number of polygon subdivisions on a triangle and two smaller polygons, must be 2 or larger
+   */
   maxPolygonSubdivisions: number;
+  /**
+   * Specifies triangulation metric
+   * default for MR::fillHole: getCircumscribedFillMetric
+   * @see FillHoleMetric
+   */
+  metric: FillHoleMetric;
+}
+
+/**
+ * @brief Parameters structure for MR::stitchHoles
+ * Structure has some options to control MR::stitchHoles.
+ *
+ * @see stitchHoles
+ *
+ * @see FillHoleMetric
+ */
+export interface StitchHolesParams extends ClassHandle {
+  /**
+   * Specifies triangulation metric
+   * default for MR::stitchHoles: getComplexStitchMetric @see FillHoleMetric
+   */
+  metric: FillHoleMetric;
 }
 
 export interface FixMeshDegeneraciesModeValue<T extends number> {
@@ -366,132 +898,538 @@ export interface FixMeshDegeneraciesModeValue<T extends number> {
 export type FixMeshDegeneraciesMode = FixMeshDegeneraciesModeValue<0>|FixMeshDegeneraciesModeValue<1>|FixMeshDegeneraciesModeValue<2>;
 
 export interface FixMeshDegeneraciesParams extends ClassHandle {
+  /**
+   * @brief maximum permitted deviation from the original surface
+   */
   maxDeviation: number;
+  /**
+   * @brief edges not longer than this value will be collapsed ignoring normals and aspect ratio checks
+   */
   tinyEdgeLength: number;
+  /**
+   * the algorithm will ignore dihedral angle check if one of triangles had aspect ratio equal or more than this value; and the algorithm will permit temporary increase in aspect ratio after collapse, if before collapse one of the triangles had larger aspect ratio
+   */
   criticalTriAspectRatio: number;
+  /**
+   * @brief Permit edge flips if it does not change dihedral angle more than on this value.
+   */
   maxAngleChange: number;
+  /**
+   * Small stabilizer is important to achieve good results on completely planar mesh parts, if your mesh is not-planer everywhere, then you can set it to zero
+   */
   stabilizer: number;
   mode: FixMeshDegeneraciesMode;
+  /**
+   * trying to stay close to initial surface when patching also disables smoothing on patch
+   */
   mimicPatch: boolean;
 }
 
 export interface MeshLoad extends ClassHandle {
 }
 
+export interface MeshMeshCollisionStatusValue<T extends number> {
+  value: T;
+}
+export type MeshMeshCollisionStatus = MeshMeshCollisionStatusValue<0>|MeshMeshCollisionStatusValue<1>|MeshMeshCollisionStatusValue<2>|MeshMeshCollisionStatusValue<3>|MeshMeshCollisionStatusValue<4>|MeshMeshCollisionStatusValue<5>|MeshMeshCollisionStatusValue<6>;
+
+type MeshDistanceResult = { a: PointOnFace; b: PointOnFace; distSq: number };
+
+type MeshMeshSignedDistanceResult = {
+  /**
+   * @brief two closest points: from meshes A and B respectively
+   */
+  a: PointOnFace;
+  b: PointOnFace;
+  /**
+   * @brief mutual status of two meshes
+   */
+  status: number;
+  /**
+   * @brief signed distance between a and b, positive if meshes do not collide
+   */
+  signedDist: number;
+};
+
+/**
+ * @brief Holds metrics for fillHole and stitchHoles triangulation
+ * .
+ *
+ * This is struct used as optimization metric of fillHole and stitchHoles functions
+ * @see getCircumscribedMetric
+ *
+ * @see getPlaneFillMetric
+ *
+ * @see getEdgeLengthFillMetric
+ *
+ * @see getEdgeLengthStitchMetric
+ *
+ * @see getComplexStitchMetric
+ *
+ * @see fillHole
+ *
+ * @see stitchHoles
+ */
 export interface FillHoleMetric extends ClassHandle {
 }
 
+/**
+ * This class can hold either mesh part or point cloud. It is used for generic algorithms operating with either of them
+ */
 export interface MeshOrPoints extends ClassHandle {
 }
 
+/**
+ * @brief an object and its transformation to global space with other objects
+ */
 export interface MeshOrPointsXf extends ClassHandle {
   xf: AffineXf3f;
 }
 
+type MeshProjectionResult = {
+  /**
+   * @brief the closest point on mesh, transformed by xf if it is given
+   */
+  proj: PointOnFace;
+  /**
+   * @brief its barycentric representation
+   */
+  mtp: MeshTriPoint;
+  /**
+   * @brief squared distance from original projected point to proj
+   */
+  distSq: number;
+  /**
+   * @brief check for validity, otherwise the projection was not found
+   */
+  valid: boolean;
+};
+
+type SignedMeshProjectionResult = { proj: PointOnFace; mtp: MeshTriPoint; dist: number } | null;
+
 export interface MeshRelaxParams extends ClassHandle {
   iterations: number;
   force: number;
   limitNearInitial: boolean;
   maxInitialDist: number;
+  /**
+   * @brief move all region vertices with exactly three neighbor vertices in the center of the neighbors
+   */
   hardSmoothTetrahedrons: boolean;
 }
 
 export interface MeshSave extends ClassHandle {
 }
 
+export interface SubdivideSettings extends ClassHandle {
+  /**
+   * @brief Subdivision is stopped when all edges inside or on the boundary of the region are not longer than this value.
+   */
+  maxEdgeLen: number;
+  /**
+   * edge length will be magnified by the squared difference of normals at edge's ends times this factor, thus subdivision will be finer in the regions of high curvature compared to planar regions
+   */
+  curvaturePriority: number;
+  /**
+   * @brief Maximum number of edge splits allowed.
+   */
+  maxEdgeSplits: number;
+  /**
+   * @brief Improves local mesh triangulation by doing edge flips if it does not make too big surface deviation.
+   */
+  maxDeviationAfterFlip: number;
+  /**
+   * @brief Improves local mesh triangulation by doing edge flips if it does not change dihedral angle more than on this value (in radians)
+   */
+  maxAngleChangeAfterFlip: number;
+  /**
+   * If this value is less than FLT_MAX then edge flips will ignore dihedral angle check if one of triangles has aspect ratio more than this value Unit: rad
+   */
+  criticalAspectRatioFlip: number;
+  /**
+   * If false do not touch border edges (cannot subdivide lone faces)
+   * use MR::findRegionOuterFaces to find boundary faces
+   */
+  subdivideBorder: boolean;
+  /**
+   * @brief The subdivision stops as soon as all triangles (in the region) have aspect ratio below or equal to this value.
+   */
+  maxTriAspectRatio: number;
+  /**
+   * An edge is subdivided only if both its left and right triangles have aspect ratio below or equal to this value. So this is a maximum aspect ratio of a triangle that can be split on two before Delone optimization. Please set it to a smaller value only if subdivideBorder==false, otherwise many narrow triangles can appear near border
+   */
+  maxSplittableTriAspectRatio: number;
+  /**
+   * Puts new vertices so that they form a smooth surface together with existing vertices. This option works best for natural surfaces without sharp edges in between triangles
+   */
+  smoothMode: boolean;
+  /**
+   * In case of activated smoothMode, the smoothness is locally deactivated at the edges having dihedral angle at least this value
+   */
+  minSharpDihedralAngle: number;
+  /**
+   * @brief if true, then every new vertex will be projected on the original mesh (before smoothing)
+   */
+  projectOnOriginalMesh: boolean;
+}
+
+/**
+ * Mesh Topology
+ */
 export interface MeshTopology extends ClassHandle {
+  /**
+   * @brief returns cached set of all valid vertices
+   */
   getValidVerts(): VertBitSet;
+  /**
+   * @brief returns cached set of all valid faces
+   */
   getValidFaces(): FaceBitSet;
+  /**
+   * @brief returns the number of face records including invalid ones
+   */
   faceSize(): number;
+  /**
+   * returns the number of hole loops in the mesh; @param holeRepresentativeEdges optional output of the smallest edge id with no valid left face in every hole
+   */
   findNumHoles(): number;
-  getTriVerts(_0: number): any;
-  getLeftTriVerts(_0: number): any;
-  findHoleRepresentiveEdges(): any;
+  /**
+   * gets 3 vertices of given triangular face; the vertices are returned in counter-clockwise order if look from mesh outside
+   */
+  getTriVerts(f: number): Uint32Array;
+  /**
+   * gets 3 vertices of the left face ( face-id may not exist, but the shape must be triangular) the vertices are returned in counter-clockwise order if look from mesh outside: v0 = org( a ), v1 = dest( a )
+   */
+  getLeftTriVerts(a: number): Uint32Array;
+  /**
+   * returns one edge with no valid left face for every boundary in the mesh; if region is given, then returned edges must have valid right faces from the region
+   */
+  findHoleRepresentiveEdges(): Uint32Array;
+  /**
+   * returns three vertex ids for valid triangles (which can be accessed by FaceId), vertex ids for invalid triangles are undefined, and shall not be read
+   */
   getTriangulation(): Triangulation;
 }
 
+/**
+ * encodes a point inside a triangular mesh face using barycentric coordinates
+ *
+ * Notations used below:
+ * v0 - the value in org( e )
+ * v1 - the value in dest( e )
+ * v2 - the value in dest( next( e ) )
+ */
+type MeshTriPoint = {
+  /**
+   * left face of this edge is considered
+   */
+  e: number;
+  /**
+   * barycentric coordinates
+   *
+   * a in [0,1], a=0 => point is on next( e ) edge, a=1 => point is in dest( e ) b in [0,1], b=0 => point is on e edge, b=1 => point is in dest( next( e ) ) a+b in [0,1], a+b=0 => point is in org( e ), a+b=1 => point is on prev( e.sym() ) edge
+   */
+  bary: { a: number; b: number };
+};
+
 export interface CascadeModeValue<T extends number> {
   value: T;
 }
 export type CascadeMode = CascadeModeValue<0>|CascadeModeValue<1>;
 
+/**
+ * @brief Parameters that are used for sampling of the MultiwayICP objects.
+ */
 export interface MultiwayICPSamplingParameters extends ClassHandle {
+  /**
+   * @brief sampling size of each object, 0 has special meaning "take all valid points"
+   */
   samplingVoxelSize: number;
+  /**
+   * size of maximum icp group to work with; if the number of objects exceeds this value, icp is applied in cascade mode; maxGroupSize = 1 means that every object is moved independently on half distance to the previous position of all other objects; maxGroupSize = 0 means that a big system of equations for all objects is solved (force no cascading)
+   */
   maxGroupSize: number;
   cascadeMode: CascadeMode;
 }
 
+/**
+ * This class allows you to register many objects having similar parts and known initial approximations of orientations/locations using Iterative Closest Points (ICP) point-to-point or point-to-plane algorithms
+ */
 export interface MultiwayICP extends ClassHandle {
-  calculateTransformations(): any;
-  resamplePoints(_0: MultiwayICPSamplingParameters): boolean;
+  /**
+   * runs ICP algorithm given input objects, transformations, and parameters; @returns adjusted transformations of all objects to reach registered state the transformation of the last object is fixed and does not change here
+   */
+  calculateTransformations(): AffineXf3f[];
+  /**
+   * @brief select pairs with origin samples on all objects
+   */
+  resamplePoints(samplingParams: MultiwayICPSamplingParameters): boolean;
+  /**
+   * in each pair updates the target data and performs basic filtering (activation) in cascade mode only useful for stats update
+   */
   updateAllPointPairs(): boolean;
-  setParams(_0: ICPProperties): void;
+  /**
+   * @brief tune algorithm params before run calculateTransformations()
+   */
+  setParams(prop: ICPProperties): void;
   getParams(): ICPProperties;
+  /**
+   * computes root-mean-square deviation between points or the standard deviation from given value if present
+   */
   getMeanSqDistToPoint(): number;
+  /**
+   * computes root-mean-square deviation from points to target planes or the standard deviation from given value if present
+   */
   getMeanSqDistToPlane(): number;
+  /**
+   * @brief computes the number of samples able to form pairs
+   */
   getNumSamples(): number;
+  /**
+   * @brief computes the number of active point pairs
+   */
   getNumActivePairs(): number;
+  /**
+   * @brief returns status info string
+   */
   getStatusInfo(): string;
 }
 
+export interface DenoiseViaNormalsSettings extends ClassHandle {
+  /**
+   * @brief use approximated computation, which is much faster than precise solution
+   */
+  fastIndicatorComputation: boolean;
+  /**
+   * @brief 0.001 - sharp edges, 0.01 - moderate edges, 0.1 - smooth edges
+   */
+  beta: number;
+  /**
+   * @brief the amount of smoothing: 0 - no smoothing, 1 - average smoothing, ...
+   */
+  gamma: number;
+  /**
+   * @brief the number of iterations to smooth normals and find creases; the more the better quality, but longer computation
+   */
+  normalIters: number;
+  /**
+   * @brief the number of iterations to update vertex coordinates from found normals; the more the better quality, but longer computation
+   */
+  pointIters: number;
+  /**
+   * @brief how much resulting points must be attracted to initial points (e.g. to avoid general shrinkage), must be > 0
+   */
+  guideWeight: number;
+  /**
+   * @brief if true then maximal displacement of each point during denoising will be limited
+   */
+  limitNearInitial: boolean;
+  /**
+   * @brief maximum distance between a point and its position before relaxation, ignored if limitNearInitial = false
+   */
+  maxInitialDist: number;
+}
+
 export interface BaseShellParameters extends ClassHandle {
+  /**
+   * Size of voxel in grid conversions; The user is responsible for setting some positive value here
+   */
   voxelSize: number;
 }
 
 export interface OffsetParameters extends BaseShellParameters {
+  /**
+   * use FunctionVolume for voxel grid representation:
+   * - memory consumption for voxel storage is approx. (dims.z / (2 * thread_count)) lesser
+   * - computations are about 15% slower (because some z-layers are computed twice) this setting is ignored (as if memoryEfficient == false) if a) signDetectionMode = SignDetectionMode::OpenVDB, or b) fwn is provided (CUDA computations require full memory storage) used only by mcOffsetMesh and sharpOffsetMesh methods
+   */
   memoryEfficient: boolean;
+  /**
+   * determines the method to compute distance sign; offsetMesh implementing OffsetMode::Smooth supports only Unsigned, OpenVDB and HoleWindingRule here
+   */
   signDetectionMode: SignDetectionMode;
 }
 
 export interface SharpOffsetParameters extends OffsetParameters {
+  /**
+   * @brief minimal surface deviation to introduce new vertex in a voxel, measured in voxelSize
+   */
   minNewVertDev: number;
+  /**
+   * @brief maximal surface deviation to introduce new rank 2 vertex (on intersection of 2 planes), measured in voxelSize
+   */
   maxNewRank2VertDev: number;
+  /**
+   * @brief maximal surface deviation to introduce new rank 3 vertex (on intersection of 3 planes), measured in voxelSize
+   */
   maxNewRank3VertDev: number;
+  /**
+   * correct positions of the input vertices using reference mesh by not more than this distance, measured in voxelSize; big correction can be wrong and result from self-intersections in the reference mesh
+   */
   maxOldVertPosCorrection: number;
 }
 
+/**
+ * @brief allows the user to select in the parameters which offset algorithm to call
+ */
 export interface GeneralOffsetParameters extends SharpOffsetParameters {
   mode: OffsetMode;
 }
 
+/**
+ * @brief Special data type for MR::cutMesh.
+ *
+ * This is special data for MR::cutMesh, you can convert some other contours representation to it by:
+ * MR::convertMeshTriPointsToClosedContour MR::convertSurfacePathsToMeshContours
+ */
 export interface OneMeshContours extends ClassHandle {
 }
 
 export interface PointCloud extends ClassHandle {
-  readonly validPoints: VertBitSet;
+  /**
+   * @brief only points and normals corresponding to set bits here are valid
+   */
+  validPoints: VertBitSet;
+  /**
+   * @brief coordinates of points
+   */
   readonly points: VertCoords;
+  /**
+   * @brief unit normal directions of points (can be empty if no normals are known)
+   */
   readonly normals: VertCoords;
+  /**
+   * passes through all valid points and finds the minimal bounding box containing all of them; if toWorld transformation is given then returns minimal bounding box in world space
+   */
   computeBoundingBox(): Box3f;
-  addPoint(_0: Vector3f): number;
+  /**
+   * @brief Invalidates caches (e.g. aabb-tree) after a change in point cloud.
+   */
+  invalidateCaches(): void;
+  /**
+   * @brief appends a point and returns its VertId
+   */
+  addPoint(point: Vector3f): number;
 }
 
+/**
+ * @brief Parameters of point cloud triangulation.
+ *
+ * @see triangulatePointCloud
+ */
 export interface TriangulationParameters extends ClassHandle {
+  /**
+   * @brief The number of nearest neighbor points to use for building of local triangulation.
+   *
+   * @note Too small value can make not optimal triangulation and additional holes
+   * Too big value increases difficulty of optimization and decreases performance
+   */
   numNeighbours: number;
+  /**
+   * Radius of neighborhood around each point to consider for building local triangulation. This is an alternative to numNeighbours parameter. Please set to positive value only one of them.
+   */
   radius: number;
+  /**
+   * @brief Critical angle of triangles in local triangulation (angle between triangles in fan should be less then this value)
+   */
   critAngle: number;
+  /**
+   * @brief Critical length of hole (all holes with length less then this value will be filled)
+   *
+   * If value is subzero it is set automaticly to 0.7*bbox.diagonal()
+   */
   critHoleLength: number;
+  /**
+   * @brief automatic increase of the radius if points outside can make triangles from original radius not-Delone
+   */
   automaticRadiusIncrease: boolean;
 }
 
+/**
+ * @brief a point located on some mesh's face
+ */
+type PointOnFace = {
+  /**
+   * @brief mesh's face containing the point
+   */
+  face: number;
+  /**
+   * @brief a point of the mesh's face
+   */
+  point: Vector3f;
+};
+
 export interface PointsLoad extends ClassHandle {
 }
 
 export interface PointsSave extends ClassHandle {
 }
 
+export interface PointsToMeshParameters extends ClassHandle {
+  /**
+   * it the distance of highest influence of a point; the maximal influence distance is 3*sigma; beyond that distance the influence is strictly zero
+   */
+  sigma: number;
+  /**
+   * @brief minimum sum of influence weights from surrounding points for a triangle to appear, meaning that there shall be at least this number of points in close proximity
+   */
+  minWeight: number;
+  /**
+   * coefficient used for weight calculation: e^(dist^2 * -invSigmaModifier * sigma^-2) values: (0;inf)
+   */
+  invSigmaModifier: number;
+  /**
+   * changes the way point angle affects weight, by default it is linearly increasing with dot product if enabled - increasing as dot product^(0.5) (with respect to its sign)
+   */
+  sqrtAngleWeight: boolean;
+  /**
+   * Size of voxel in grid conversions; The user is responsible for setting some positive value here
+   */
+  voxelSize: number;
+}
+
 export interface MeshProjectionParameters extends ClassHandle {
+  /**
+   * minimum squared distance from a test point to mesh to be computed precisely, if a mesh point is found within this distance then it is immediately returned without searching for a closer one
+   */
   loDistLimitSq: number;
+  /**
+   * maximum squared distance from a test point to mesh to be computed precisely, if actual distance is larger than upDistLimit will be returned with not-trusted sign
+   */
   upDistLimitSq: number;
 }
 
+/**
+ * @brief this struct contains coordinate converters float-int-float
+ */
 export interface CoordinateConverters extends ClassHandle {
 }
 
 export interface SignDetectionModeValue<T extends number> {
   value: T;
 }
+/**
+ * @brief how to determine the sign of distances from a mesh
+ */
 export type SignDetectionMode = SignDetectionModeValue<0>|SignDetectionModeValue<1>|SignDetectionModeValue<2>|SignDetectionModeValue<3>|SignDetectionModeValue<4>;
 
+export interface UniformSamplingSettings extends ClassHandle {
+  /**
+   * @brief minimal distance between samples
+   */
+  distance: number;
+  /**
+   * if point cloud has normals then automatically decreases local distance to make sure that all points inside have absolute normal dot product not less than this value; this is to make sampling denser in the regions of high curvature; value <=0 means ignore normals; value >=1 means select all points (practically useless)
+   */
+  minNormalDot: number;
+  /**
+   * if true process the points in lexicographical order, which gives tighter and more uniform samples; if false process the points according to their ids, which is faster
+   */
+  lexicographicalOrder: boolean;
+}
+
+type GridMinMax = { min: number; max: number };
+
 export interface MeshToVolumeTypeValue<T extends number> {
   value: T;
 }
@@ -504,12 +1442,30 @@ export interface MeshToVolumeParams extends ClassHandle {
   voxelSize: Vector3f;
 }
 
+/**
+ * @brief parameters of OpenVDB Grid to Mesh conversion using Dual Marching Cubes algorithm
+ */
 export interface GridToMeshSettings extends ClassHandle {
+  /**
+   * @brief layer of grid with this value would be converted in mesh; isoValue can be negative only in level set grids
+   */
   isoValue: number;
+  /**
+   * @brief adaptivity - [0.0;1.0] ratio of combining small triangles into bigger ones (curvature can be lost on high values)
+   */
   adaptivity: number;
+  /**
+   * @brief if the mesh exceeds this number of faces, an error returns
+   */
   maxFaces: number;
+  /**
+   * @brief if the mesh exceeds this number of vertices, an error returns
+   */
   maxVertices: number;
   relaxDisorientedTriangles: boolean;
+  /**
+   * @brief the size of each voxel in the grid
+   */
   voxelSize: Vector3f;
 }
 
@@ -522,31 +1478,38 @@ export interface VdbVolume extends ClassHandle {
 }
 
 export interface VertCoords extends ClassHandle {
-  toArray(): any;
+  toArray(): Float32Array;
+  size(): number;
+  get(i: number): Vector3f;
+  set(i: number, p: Vector3f): void;
+}
+
+export interface VertScalars extends ClassHandle {
+  toArray(): Float32Array;
 }
 
 export interface Triangulation extends ClassHandle {
-  toArray(): any;
+  toArray(): Uint32Array;
 }
 
 export interface FaceNormals extends ClassHandle {
-  toArray(): any;
+  toArray(): Float32Array;
 }
 
 export interface VertMap extends ClassHandle {
-  toArray(): any;
+  toArray(): Uint32Array;
 }
 
 export interface FaceMap extends ClassHandle {
-  toArray(): any;
+  toArray(): Uint32Array;
 }
 
 export interface Face2RegionMap extends ClassHandle {
-  toArray(): any;
+  toArray(): Uint32Array;
 }
 
 export interface VertColors extends ClassHandle {
-  toArray(): any;
+  toArray(): Uint8Array;
 }
 
 export type Vector3f = {
@@ -561,13 +1524,47 @@ export type Vector3i = {
   z: number
 };
 
+/**
+ * three-dimensional vector
+ */
+export interface Vector3 extends ClassHandle {
+}
+
 export interface VoxelsLoad extends ClassHandle {
 }
 
 export interface VoxelsSave extends ClassHandle {
 }
 
+export interface WeightedShellParametersBase extends ClassHandle {
+  /**
+   * @brief build iso-surface of minimal distance to points corresponding to this value
+   */
+  offset: number;
+  /**
+   * Size of voxel in grid conversions; The user is responsible for setting some positive value here
+   */
+  voxelSize: number;
+  /**
+   * @brief number of voxels to compute near the offset (should be left default unless used for debugging)
+   */
+  numLayers: number;
+}
+
+export interface WeightedShellParametersMetric extends WeightedShellParametersBase {
+  /**
+   * @brief parameters of distance finding
+   */
+  dist: DistanceFromWeightedPointsParams;
+}
+
+export interface WeightedShell extends ClassHandle {
+}
+
 interface EmbindModule {
+  NoiseSettings: {
+    new(): NoiseSettings;
+  };
   AffineXf3f: {
     new(): AffineXf3f;
     new(_0: Matrix3f, _1: Vector3f): AffineXf3f;
@@ -576,23 +1573,23 @@ interface EmbindModule {
   };
   BitSet: {
     new(): BitSet;
-    fromIndices(_0: any): BitSet;
+    fromIndices(indices: readonly number[] | Uint32Array): BitSet;
   };
   FaceBitSet: {
     new(): FaceBitSet;
-    fromIndices(_0: any): FaceBitSet;
+    fromIndices(indices: readonly number[] | Uint32Array): FaceBitSet;
   };
   VertBitSet: {
     new(): VertBitSet;
-    fromIndices(_0: any): VertBitSet;
+    fromIndices(indices: readonly number[] | Uint32Array): VertBitSet;
   };
   EdgeBitSet: {
     new(): EdgeBitSet;
-    fromIndices(_0: any): EdgeBitSet;
+    fromIndices(indices: readonly number[] | Uint32Array): EdgeBitSet;
   };
   UndirectedEdgeBitSet: {
     new(): UndirectedEdgeBitSet;
-    fromIndices(_0: any): UndirectedEdgeBitSet;
+    fromIndices(indices: readonly number[] | Uint32Array): UndirectedEdgeBitSet;
   };
   Box3f: {
     new(): Box3f;
@@ -602,7 +1599,18 @@ interface EmbindModule {
     new(): Box3i;
     new(_0: Vector3i, _1: Vector3i): Box3i;
   };
+  DistanceFromWeightedPointsParams: {
+    new(): DistanceFromWeightedPointsParams;
+  };
+  /**
+   * Caller can avoid filling non-needed part of cut faces to speedup cutting still add pseudo FaceId to opposite side to keep connectivity
+   */
   FillPart: {Both: FillPartValue<0>, Left: FillPartValue<1>, Right: FillPartValue<2>};
+  /**
+   * This enum defines the MR::cutMesh behaviour in case of bad faces acure basicaly MR::cutMesh removes all faces which contours pass through, adds new edges to topology and fills all removed parts
+   *
+   * @note Bad faces here mean faces where contours have intersections and cannot be cut and filled in an good way
+   */
   ForceFill: {None: ForceFillValue<0>, Good: ForceFillValue<1>, All: ForceFillValue<2>};
   CutMeshParameters: {
     new(): CutMeshParameters;
@@ -610,7 +1618,13 @@ interface EmbindModule {
   CutByProjectionSettings: {
     new(): CutByProjectionSettings;
   };
+  /**
+   * @brief determines the weight of each edge in applications like Laplacian
+   */
   EdgeWeights: {Unit: EdgeWeightsValue<0>, Cotan: EdgeWeightsValue<1>};
+  /**
+   * @brief determines the weight or mass of each vertex in applications like Laplacian
+   */
   VertexMass: {Unit: VertexMassValue<0>, NeiArea: VertexMassValue<1>};
   RememberShape: {Yes: RememberShapeValue<0>, No: RememberShapeValue<1>};
   OffsetMode: {Smooth: OffsetModeValue<0>, Standard: OffsetModeValue<1>, Sharpening: OffsetModeValue<2>};
@@ -623,144 +1637,481 @@ interface EmbindModule {
   FillHoleNicelySettings: {
     new(): FillHoleNicelySettings;
   };
+  /**
+   * @brief Fix method.
+   */
   SelfIntersectionsMethod: {Relax: SelfIntersectionsMethodValue<0>, CutAndFill: SelfIntersectionsMethodValue<1>};
   SelfIntersectionsSettings: {
     new(): SelfIntersectionsSettings;
   };
   SelfIntersections: {
-    getFaces(_0: Mesh, _1: boolean): FaceBitSet;
-    fix(_0: Mesh, _1: SelfIntersectionsSettings): void;
+    /**
+     * @brief Find all self-intersections faces component-wise.
+     */
+    getFaces(mesh: Mesh, touchIsIntersection: boolean): FaceBitSet;
+    /**
+     * @brief Finds and fixes self-intersections per component:
+     */
+    fix(mesh: Mesh, settings: SelfIntersectionsSettings): void;
   };
   FloatGrid: {
     new(): FloatGrid;
   };
-  resampled(_0: FloatGrid, _1: number): FloatGrid;
-  resampled(_0: FloatGrid, _1: number, _2: number, _3: number): FloatGrid;
-  cropped(_0: FloatGrid, _1: Box3i): FloatGrid;
+  /**
+   * @brief resample this grid to fit voxelScale
+   */
+  resampled(grid: FloatGrid, voxelScale: number): FloatGrid;
+  /**
+   * @brief resample this grid to fit voxelScale
+   */
+  resampled(grid: FloatGrid, scaleX: number, scaleY: number, scaleZ: number): FloatGrid;
+  /**
+   * @brief returns cropped grid
+   */
+  cropped(grid: FloatGrid, box: Box3i): FloatGrid;
   FreeFormDeformer: {
-    new(_0: Mesh | null): FreeFormDeformer;
+    new(mesh: Mesh | null): FreeFormDeformer;
   };
+  /**
+   * @brief The method how to update transformation from point pairs.
+   */
   ICPMethod: {Combined: ICPMethodValue<0>, PointToPoint: ICPMethodValue<1>, PointToPlane: ICPMethodValue<2>};
+  /**
+   * @brief The group of transformations, each with its own degrees of freedom.
+   */
   ICPMode: {RigidScale: ICPModeValue<0>, AnyRigidXf: ICPModeValue<1>, OrthogonalAxis: ICPModeValue<2>, FixedAxis: ICPModeValue<3>, TranslationOnly: ICPModeValue<4>};
   ICPExitType: {NotStarted: ICPExitTypeValue<0>, NotFoundSolution: ICPExitTypeValue<1>, MaxIterations: ICPExitTypeValue<2>, MaxBadIterations: ICPExitTypeValue<3>, StopMsdReached: ICPExitTypeValue<4>};
   ICPProperties: {
     new(): ICPProperties;
   };
   ICP: {
-    new(_0: MeshOrPointsXf, _1: MeshOrPointsXf, _2: number): ICP;
-    new(_0: MeshOrPointsXf, _1: MeshOrPointsXf, _2: VertBitSet, _3: VertBitSet): ICP;
+    new(flt: MeshOrPointsXf, ref: MeshOrPointsXf, samplingVoxelSize: number): ICP;
+    new(flt: MeshOrPointsXf, ref: MeshOrPointsXf, fltSamples: VertBitSet, refSamples: VertBitSet): ICP;
   };
   ContinuousContours: {};
   Laplacian: {
-    new(_0: Mesh | null): Laplacian;
+    new(mesh: Mesh | null): Laplacian;
   };
   Matrix3f: {
     new(): Matrix3f;
     new(_0: Vector3f, _1: Vector3f, _2: Vector3f): Matrix3f;
     identity(): Matrix3f;
     zero(): Matrix3f;
-    rotation(_0: Vector3f, _1: number): Matrix3f;
+    rotation(axis: Vector3f, angle: number): Matrix3f;
   };
   Mesh: {
-    fromTriangles(_0: VertCoords, _1: Triangulation): Mesh | null;
-    fromTrianglesDuplicatingNonManifoldVertices(_0: VertCoords, _1: Triangulation): Mesh | null;
-  };
-  cutMeshByProjection(_0: Mesh | null, _1: any, _2: CutByProjectionSettings): any;
-  makeConvexHullFromMesh(_0: Mesh | null): Mesh | null;
-  makeCylinderAdvanced(_0: number, _1: number, _2: number, _3: number, _4: number, _5: number): Mesh | null;
-  fillHoleNicely(_0: Mesh | null, _1: number, _2: FillHoleNicelySettings): FaceBitSet;
-  makeSphere(_0: SphereParams): Mesh | null;
-  makeUVSphere(_0: number, _1: number, _2: number): Mesh | null;
+    /**
+     * @brief construct mesh from vertex coordinates and a set of triangles with given ids
+     */
+    fromTriangles(vertexCoordinates: VertCoords, t: Triangulation): Mesh | null;
+    /**
+     * construct mesh from vertex coordinates and a set of triangles with given ids; unlike simple fromTriangles() it tries to resolve non-manifold vertices by creating duplicate vertices; `betterCont` (if given) selects the best triangle among several possible continuations during the duplication
+     */
+    fromTrianglesDuplicatingNonManifoldVertices(vertexCoordinates: VertCoords, t: Triangulation): Mesh | null;
+  };
+  addNoise(mesh: Mesh | null, settings: NoiseSettings): void;
+  /**
+   * @brief Performs orthographic projection with of given contours to mesh and cut result lines, fails if any point of contours has missed mesh on projection stage or cut contours contains self-intersections
+   *
+   * @note it might be useful to subdivide mesh before cut, to avoid issues related to lone contours
+   *
+   * @param mesh for cutting, it will be changed
+   * @param contours for projection onto mesh
+   * @param settings to specify direction and `contours` to `mesh` space transformation
+   *
+   * @returns newly appeared edges on the mesh after cut or error
+   */
+  cutMeshByProjection(mesh: Mesh | null, contours: readonly Float32Array[], settings: CutByProjectionSettings): Uint32Array[];
+  makeConvexHullFromMesh(mesh: Mesh | null): Mesh | null;
+  /**
+   * creates box mesh with given min-corner (base) and given size in every dimension; with default parameters, creates unit cube mesh with the centroid in (0,0,0)
+   */
+  makeCube(): Mesh | null;
+  makeCylinderAdvanced(radius0: number, radius1: number, start_angle: number, arc_size: number, length: number, resolution: number): Mesh | null;
+  /**
+   * fills a hole in mesh specified by one of its edge, optionally subdivides new patch on smaller triangles, optionally make smooth connection with existing triangles outside the hole @returns triangles of the patch
+   */
+  fillHoleNicely(mesh: Mesh | null, holeEdge: number, settings: FillHoleNicelySettings): FaceBitSet;
+  /**
+   * @brief creates a mesh of sphere with irregular triangulation
+   */
+  makeSphere(params: SphereParams): Mesh | null;
+  /**
+   * @brief creates a mesh of sphere with regular triangulation (parallels and meridians)
+   */
+  makeUVSphere(radius: number, horisontalResolution: number, verticalResolution: number): Mesh | null;
+  /**
+   * Enum class of available CSG operations
+   * @see MR::boolean
+   */
   BooleanOperation: {InsideA: BooleanOperationValue<0>, InsideB: BooleanOperationValue<1>, OutsideA: BooleanOperationValue<2>, OutsideB: BooleanOperationValue<3>, Union: BooleanOperationValue<4>, Intersection: BooleanOperationValue<5>, DifferenceBA: BooleanOperationValue<6>, DifferenceAB: BooleanOperationValue<7>};
   BooleanResult: {};
-  boolean(_0: Mesh | null, _1: Mesh | null, _2: BooleanOperation): BooleanResult;
+  /**
+   * @brief Performs CSG operation on two meshes.
+   *
+   * Makes new mesh - result of boolean operation on mesh `A` and mesh `B`  @param meshA Input mesh `A`
+   * @param meshB Input mesh `B`
+   * @param operation CSG operation to perform
+   * @param rigidB2A Transform from mesh `B` space to mesh `A` space
+   * @param mapper Optional output structure to map mesh `A` and mesh `B` topology to result mesh topology
+   *
+   * @note Input meshes should have no self-intersections in intersecting zone
+   *
+   * @note If meshes are not closed in intersecting zone some boolean operations are not allowed (as far as input meshes interior and exterior cannot be determined)
+   */
+  boolean(meshA: Mesh | null, meshB: Mesh | null, operation: BooleanOperation): BooleanResult;
+  /**
+   * @brief Input object index enum.
+   */
   BooleanMapObject: {A: BooleanMapObjectValue<0>, B: BooleanMapObjectValue<1>};
   BooleanResultMapper: {
     new(): BooleanResultMapper;
   };
-  boolean(_0: Mesh | null, _1: Mesh | null, _2: BooleanOperation, _3: BooleanResultMapper): BooleanResult;
+  /**
+   * @brief Performs CSG operation on two meshes.
+   *
+   * Makes new mesh - result of boolean operation on mesh `A` and mesh `B`  @param meshA Input mesh `A`
+   * @param meshB Input mesh `B`
+   * @param operation CSG operation to perform
+   * @param rigidB2A Transform from mesh `B` space to mesh `A` space
+   * @param mapper Optional output structure to map mesh `A` and mesh `B` topology to result mesh topology
+   *
+   * @note Input meshes should have no self-intersections in intersecting zone
+   *
+   * @note If meshes are not closed in intersecting zone some boolean operations are not allowed (as far as input meshes interior and exterior cannot be determined)
+   */
+  boolean(meshA: Mesh | null, meshB: Mesh | null, operation: BooleanOperation, mapper: BooleanResultMapper): BooleanResult;
   MeshBuilder: {
-    uniteCloseVertices(_0: Mesh | null, _1: number, _2: boolean): number;
+    /**
+     * the function finds groups of mesh vertices located closer to each other than@param closeDist and unites such vertices in one; then the mesh is rebuilt from the remaining triangles
+     * @param optionalVertOldToNew is the mapping of vertices: before -> after
+     * @param uniteOnlyBd if true then only boundary vertices can be united, all internal vertices (even close ones) will remain
+     *
+     * @returns the number of vertices united, 0 means no change in the mesh
+     */
+    uniteCloseVertices(mesh: Mesh | null, closeDist: number, uniteOnlyBd: boolean): number;
   };
-  isInside(_0: Mesh | null, _1: Mesh | null): boolean;
+  /**
+   * @brief checks that arbitrary mesh part A is inside of closed mesh part B
+   *
+   * @param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
+   */
+  isInside(a: Mesh | null, b: Mesh | null): boolean;
+  /**
+   * @brief finds all pairs of colliding triangles from two meshes or two mesh regions
+   *
+   * @param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
+   * @param firstIntersectionOnly if true then the function returns at most one pair of intersecting triangles and returns faster
+   */
+  findCollidingTriangles(a: Mesh | null, b: Mesh | null): FaceFace[];
+  /**
+   * @brief finds all pairs of colliding triangles from two meshes or two mesh regions
+   *
+   * @param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
+   * @param firstIntersectionOnly if true then the function returns at most one pair of intersecting triangles and returns faster
+   */
+  findCollidingTriangles(a: Mesh | null, b: Mesh | null, firstIntersectionOnly: boolean): FaceFace[];
+  /**
+   * @brief the same as findCollidingTriangles, but returns one bite set per mesh with colliding triangles
+   */
+  findCollidingTriangleBitsets(a: Mesh | null, b: Mesh | null): CollidingTriangleBitsets;
+  /**
+   * @brief finds all pairs (or the fact of any self-collision) of colliding triangles from one mesh or a region
+   *
+   * if true then treat touching faces as self-intersections too
+   */
+  findSelfCollidingTriangles(mp: Mesh | null): FaceFace[];
+  /**
+   * @brief the same findSelfCollidingTriangles but returns the union of all self-intersecting faces
+   *
+   * if true then treat touching faces as self-intersections too
+   */
+  findSelfCollidingTrianglesBS(mp: Mesh | null): FaceBitSet;
+  VarEdgeTri: {};
   PreciseCollisionResult: {};
+  /**
+   * @brief Face incidence type.
+   */
   MeshComponentsFaceIncidence: {PerEdge: MeshComponentsFaceIncidenceValue<0>, PerVertex: MeshComponentsFaceIncidenceValue<1>};
   MeshComponents: {
-    getComponent(_0: Mesh | null, _1: number, _2: MeshComponentsFaceIncidence): FaceBitSet;
-    getComponents(_0: Mesh | null, _1: FaceBitSet, _2: MeshComponentsFaceIncidence): FaceBitSet;
-    getLargestComponent(_0: Mesh | null, _1: MeshComponentsFaceIncidence, _2: number): FaceBitSet;
-    getLargeByAreaComponents(_0: Mesh | null, _1: number): FaceBitSet;
-    getNumComponents(_0: Mesh | null, _1: MeshComponentsFaceIncidence): number;
-    getAllComponents(_0: Mesh | null, _1: MeshComponentsFaceIncidence): any;
-    getAllComponentsMap(_0: Mesh | null, _1: MeshComponentsFaceIncidence): any;
-    getLargeByAreaRegions(_0: Mesh | null, _1: Face2RegionMap, _2: number, _3: number): any;
+    /**
+     * returns one connected component containing given face, not effective to call more than once, if several components are needed use getAllComponents
+     */
+    getComponent(meshPart: Mesh | null, id: number, incidence: MeshComponentsFaceIncidence): FaceBitSet;
+    /**
+     * @brief returns union of connected components, each of which contains at least one seed face
+     */
+    getComponents(meshPart: Mesh | null, seeds: FaceBitSet, incidence: MeshComponentsFaceIncidence): FaceBitSet;
+    /**
+     * @brief returns the largest by surface area component or empty set if its area is smaller than
+     *
+     * @param minArea optional output: the number of components in addition to returned one
+     */
+    getLargestComponent(meshPart: Mesh | null, incidence: MeshComponentsFaceIncidence, minArea: number): FaceBitSet;
+    /**
+     * @brief returns the union of connected components, each having at least given area
+     */
+    getLargeByAreaComponents(mp: Mesh | null, minArea: number): FaceBitSet;
+    /**
+     * @brief returns the number of connected components in mesh part
+     */
+    getNumComponents(meshPart: Mesh | null, incidence: MeshComponentsFaceIncidence): number;
+    /**
+     * gets all connected components of mesh part @detail if components number more than the maxComponentCount, they will be combined into groups of the same size @param maxComponentCount should be more than 1
+     *
+     * @returns pair components bitsets vector and number components in one group if components number more than maxComponentCount
+     */
+    getAllComponents(meshPart: Mesh | null, incidence: MeshComponentsFaceIncidence): FaceBitSet[];
+    /**
+     * gets all connected components of mesh part as
+     * 1. the mapping: FaceId -> Component ID in [0, 1, 2, ...)
+     * 2. the total number of components
+     */
+    getAllComponentsMap(meshPart: Mesh | null, incidence: MeshComponentsFaceIncidence): ComponentsMapResult;
+    /**
+     * returns
+     * 1. the union of all regions with area >= minArea
+     * 2. the number of such regions
+     */
+    getLargeByAreaRegions(meshPart: Mesh | null, regionMap: Face2RegionMap, numRegions: number, minArea: number): LargeByAreaRegionsResult;
   };
+  /**
+   * @brief Defines the order of edge collapses inside Decimate algorithm.
+   */
   DecimateStrategy: {MinimizeError: DecimateStrategyValue<0>, ShortestEdgeFirst: DecimateStrategyValue<1>};
   DecimateSettings: {
     new(): DecimateSettings;
   };
-  decimateMesh(_0: Mesh | null, _1: DecimateSettings): DecimateResult;
+  /**
+   * @brief Performs mesh simplification in mesh region according to the settings.
+   */
+  decimateMesh(mesh: Mesh | null, settings: DecimateSettings): DecimateResult;
   RemeshSettings: {
     new(): RemeshSettings;
   };
-  remesh(_0: Mesh | null, _1: RemeshSettings): boolean;
+  /**
+   * @brief Splits too long and eliminates too short edges from the mesh.
+   */
+  remesh(mesh: Mesh | null, settings: RemeshSettings): boolean;
+  /**
+   * @brief Create a band of degenerate faces along the border of the specified region and the rest of the mesh.
+   *
+   * The function is useful for extruding the region without changing the existing faces and creating holes
+   *
+   * @param mesh - the target mesh
+   * @param region - the region required to be separated by a band of degenerate faces
+   * @param params - optional output parameters
+   */
+  makeDegenerateBandAroundRegion(mesh: Mesh | null, region: FaceBitSet): void;
+  /**
+   * If Strong makes additional efforts to avoid creating multiple edges, in some rare cases it is not possible (cases with extremely bad topology), if you faced one try to use MR::duplicateMultiHoleVertices before MR::fillHole
+   *
+   * If Simple avoid creating edges that already exist in topology (default)
+   *
+   * If None do not avoid multiple edges
+   */
   MultipleEdgesResolveMode: {None: MultipleEdgesResolveModeValue<0>, Simple: MultipleEdgesResolveModeValue<1>, Strong: MultipleEdgesResolveModeValue<2>};
   FillHoleParams: {
     new(): FillHoleParams;
   };
-  fillHole(_0: Mesh | null, _1: number, _2: FillHoleParams): void;
-  fillHoles(_0: Mesh | null, _1: any, _2: FillHoleParams): void;
+  StitchHolesParams: {
+    new(): StitchHolesParams;
+  };
+  /**
+   * @brief Fills hole in mesh
+   * .
+   *
+   * Fills given hole represented by one of its edges (having no valid left face),
+   * uses fillHoleTrivially if cannot fill hole without multiple edges,
+   * default metric: CircumscribedFillMetric
+   *
+   * Next picture show, how newly generated faces can be smoothed MR::positionVertsSmoothly MR::subdivideMesh
+   *
+   * @param mesh mesh with hole
+   * @param a EdgeId which represents hole (should not have valid left FaceId)
+   * @param params parameters of hole filling
+   *
+   * @see stitchHoles
+   *
+   * @see fillHoleTrivially
+   *
+   * @see FillHoleParams
+   */
+  fillHole(mesh: Mesh | null, a: number, params: FillHoleParams): void;
+  /**
+   * @brief fill all holes given by their representative edges in
+   *
+   * @param as
+   */
+  fillHoles(mesh: Mesh | null, as: readonly number[] | Uint32Array, params: FillHoleParams): void;
+  /**
+   * @brief Stitches two holes in Mesh
+   * .
+   *
+   * Build cylindrical patch to fill space between two holes represented by one of their edges each,
+   * default metric: ComplexStitchMetric
+   *
+   * Next picture show, how newly generated faces can be smoothed MR::positionVertsSmoothly MR::subdivideMesh
+   *
+   * @param mesh mesh with hole
+   * @param a EdgeId which represents 1st hole (should not have valid left FaceId)
+   * @param b EdgeId which represents 2nd hole (should not have valid left FaceId)
+   * @param params parameters of holes stitching
+   *
+   * @see fillHole
+   *
+   * @see StitchHolesParams
+   */
+  stitchHoles(mesh: Mesh | null, a: number, b: number, params: StitchHolesParams): void;
   FixMeshDegeneraciesMode: {Decimate: FixMeshDegeneraciesModeValue<0>, Remesh: FixMeshDegeneraciesModeValue<1>, RemeshPatch: FixMeshDegeneraciesModeValue<2>};
   FixMeshDegeneraciesParams: {
     new(): FixMeshDegeneraciesParams;
   };
-  fixMeshDegeneracies(_0: Mesh | null, _1: FixMeshDegeneraciesParams): void;
-  fixMultipleEdges(_0: Mesh | null): void;
-  findDegenerateFaces(_0: Mesh | null, _1: number): FaceBitSet;
-  findShortEdges(_0: Mesh | null, _1: number): UndirectedEdgeBitSet;
-  findHoleComplicatingFaces(_0: Mesh | null): FaceBitSet;
+  /**
+   * @brief Fixes degenerate faces and short edges in mesh (changes topology)
+   */
+  fixMeshDegeneracies(mesh: Mesh | null, params: FixMeshDegeneraciesParams): void;
+  /**
+   * @brief resolves given multiple edges, but splitting all but one edge in each group
+   */
+  fixMultipleEdges(mesh: Mesh | null): void;
+  /**
+   * @brief finds faces having aspect ratio >= criticalAspectRatio
+   */
+  findDegenerateFaces(mp: Mesh | null, criticalAspectRatio: number): FaceBitSet;
+  /**
+   * @brief finds edges having length <= criticalLength
+   */
+  findShortEdges(mp: Mesh | null, criticalLength: number): UndirectedEdgeBitSet;
+  /**
+   * @brief adds in complicatingFaces the faces not from the wedge with largest angle of faces connected by edges incident to given vertex
+   */
+  findHoleComplicatingFaces(mesh: Mesh | null): FaceBitSet;
   MeshLoad: {
-    fromAnySupportedFormat(_0: EmbindString): Mesh | null;
+    /**
+     * @brief loads mesh from file in the format detected from file extension
+     */
+    fromAnySupportedFormat(path: EmbindString): Mesh | null;
   };
-  findDistance(_0: Mesh | null, _1: Mesh | null): any;
+  MeshMeshCollisionStatus: {BothOutside: MeshMeshCollisionStatusValue<0>, BothInside: MeshMeshCollisionStatusValue<1>, AInside: MeshMeshCollisionStatusValue<2>, BInside: MeshMeshCollisionStatusValue<3>, Colliding: MeshMeshCollisionStatusValue<4>, Touching: MeshMeshCollisionStatusValue<5>, NotColliding: MeshMeshCollisionStatusValue<6>};
+  /**
+   * @brief computes minimal distance between two meshes or two mesh regions
+   *
+   * @param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
+   * @param upDistLimitSq upper limit on the distance in question, if the real distance is larger then the function exists returning upDistLimitSq and no valid points
+   */
+  findDistance(a: Mesh | null, b: Mesh | null): MeshDistanceResult;
+  findSignedDistanceFromMesh(a: Mesh | null, b: Mesh | null): MeshMeshSignedDistanceResult;
   FillHoleMetric: {};
-  getCircumscribedMetric(_0: Mesh | null): FillHoleMetric;
-  getPlaneFillMetric(_0: Mesh | null, _1: number): FillHoleMetric;
-  getPlaneNormalizedFillMetric(_0: Mesh | null, _1: number): FillHoleMetric;
-  getComplexFillMetric(_0: Mesh | null, _1: number): FillHoleMetric;
-  getEdgeLengthFillMetric(_0: Mesh | null): FillHoleMetric;
-  getUniversalMetric(_0: Mesh | null): FillHoleMetric;
-  getMinAreaMetric(_0: Mesh | null): FillHoleMetric;
-  calcCombinedFillMetric(_0: Mesh | null, _1: FaceBitSet, _2: FillHoleMetric): number;
+  /**
+   * This metric minimizes the sum of circumcircle radii for all triangles in the triangulation. It is rather fast to calculate, and it results in typically good triangulations. It is measured in length units.
+   */
+  getCircumscribedMetric(mesh: Mesh | null): FillHoleMetric;
+  /**
+   * Same as getCircumscribedFillMetric, but with extra penalty for the triangles having normals looking in the opposite side of plane containing left of (e). It is measured in length units.
+   */
+  getPlaneFillMetric(mesh: Mesh | null, e: number): FillHoleMetric;
+  /**
+   * Similar to getPlaneFillMetric with extra penalty for the triangles having normals looking in the opposite side of plane containing left of (e), but the metric minimizes the sum of circumcircle radius times aspect ratio for all triangles in the triangulation. It is measured in length units.
+   */
+  getPlaneNormalizedFillMetric(mesh: Mesh | null, e: number): FillHoleMetric;
+  /**
+   * This metric minimizes the sum of triangleMetric for all triangles in the triangulation plus the sum edgeMetric for all edges inside and on the boundary of the triangulation.
+   * Where
+   * triangleMetric is proportional to weighted triangle area and triangle aspect ratio
+   * edgeMetric grows with angle between triangles as ( ( 1 - cos( x ) ) / ( 1 + cos( x ) ) ) ^ 4. It is unitless.
+   */
+  getComplexFillMetric(mesh: Mesh | null, e: number): FillHoleMetric;
+  /**
+   * Simple metric minimizing the sum of all edge lengths It is measured in length units.
+   */
+  getEdgeLengthFillMetric(mesh: Mesh | null): FillHoleMetric;
+  /**
+   * This metric consists of two parts 1) for each triangle: it is the circumcircle diameter, this avoids the appearance of degenerate triangles; 2) for each edge: square root of double total area of triangles to its left and right times the factor depending extensionally on absolute dihedral angle between left and right triangles, this makes visually triangulated surface as smooth as possible. It is measured in length units. For planar holes it is the same as getCircumscribedMetric.
+   */
+  getUniversalMetric(mesh: Mesh | null): FillHoleMetric;
+  /**
+   * This metric is for triangulation construction with minimal summed area of triangles. It is measured in squared length units. Warning: this metric can produce degenerated triangles
+   */
+  getMinAreaMetric(mesh: Mesh | null): FillHoleMetric;
+  /**
+   * @brief Computes combined metric after filling a hole.
+   */
+  calcCombinedFillMetric(mesh: Mesh | null, filledRegion: FaceBitSet, metric: FillHoleMetric): number;
   MeshOrPoints: {
-    fromMesh(_0: Mesh): MeshOrPoints;
-    fromPoints(_0: PointCloud): MeshOrPoints;
+    fromMesh(m: Mesh): MeshOrPoints;
+    fromPoints(pc: PointCloud): MeshOrPoints;
   };
   MeshOrPointsXf: {
-    new(_0: MeshOrPoints, _1: AffineXf3f): MeshOrPointsXf;
+    new(obj: MeshOrPoints, xf: AffineXf3f): MeshOrPointsXf;
   };
   MeshRelaxParams: {
     new(): MeshRelaxParams;
   };
-  relax(_0: Mesh | null, _1: MeshRelaxParams): boolean;
-  relaxKeepVolume(_0: Mesh | null, _1: MeshRelaxParams): boolean;
+  /**
+   * applies given number of relaxation iterations to the whole mesh ( or some region if it is specified ) @returns true if was finished successfully, false if was interrupted by progress callback
+   */
+  relax(mesh: Mesh | null, params: MeshRelaxParams): boolean;
+  /**
+   * applies given number of relaxation iterations to the whole mesh ( or some region if it is specified )
+   * do not really keeps volume but tries hard @returns true if the operation completed successfully, and false if it was interrupted by the progress callback.
+   */
+  relaxKeepVolume(mesh: Mesh | null, params: MeshRelaxParams): boolean;
   MeshSave: {
-    toAnySupportedFormat(_0: Mesh | null, _1: EmbindString): void;
+    /**
+     * @brief detects the format from file extension and save mesh to it
+     */
+    toAnySupportedFormat(mesh: Mesh | null, path: EmbindString): void;
+  };
+  SubdivideSettings: {
+    new(): SubdivideSettings;
   };
+  /**
+   * splits edges in mesh region according to the settings;
+   * @returns The total number of edge splits performed
+   */
+  subdivideMesh(mesh: Mesh | null, settings: SubdivideSettings): number;
   MeshTopology: {};
-  expandFaces(_0: MeshTopology, _1: FaceBitSet): FaceBitSet;
-  shrinkFaces(_0: MeshTopology, _1: FaceBitSet): FaceBitSet;
-  getBoundaryFaces(_0: MeshTopology, _1: FaceBitSet): FaceBitSet;
-  expandVerts(_0: MeshTopology, _1: VertBitSet, _2: number): VertBitSet;
-  shrinkVerts(_0: MeshTopology, _1: VertBitSet, _2: number): VertBitSet;
-  orderIntersectionContours(_0: MeshTopology, _1: MeshTopology, _2: PreciseCollisionResult): ContinuousContours;
+  /**
+   * returns given region with all faces sharing an edge with a region face; @param stopEdges - neighborhood via this edges will be ignored
+   */
+  expandFaces(topology: MeshTopology, region: FaceBitSet): FaceBitSet;
+  /**
+   * returns given region without all faces sharing an edge with not-region face; @param stopEdges - neighborhood via this edges will be ignored
+   */
+  shrinkFaces(topology: MeshTopology, region: FaceBitSet): FaceBitSet;
+  /**
+   * @brief returns faces from given region that have at least one neighbor face with shared edge not from the region
+   */
+  getBoundaryFaces(topology: MeshTopology, region: FaceBitSet): FaceBitSet;
+  expandVerts(topology: MeshTopology, region: VertBitSet, hops: number): VertBitSet;
+  shrinkVerts(topology: MeshTopology, region: VertBitSet, hops: number): VertBitSet;
+  /**
+   * Combines unordered input intersections (and flips orientation of intersected edges from mesh B) into ordered oriented contours with the properties:
+   * 1. Each contour is a. either closed (then its first and last elements are equal), b. or open (then its first and last intersected edges are boundary edges).
+   * 2. Next intersection in a contour is located to the left of the current intersected edge: a. if the current and next intersected triangles are the same, then next intersected edge is either next( curr.edge ) or prev( curr.edge.sym() ).sym(), b. otherwise next intersected triangle is left( curr.edge ) and next intersected edge is one of the edges having the current intersected triangle to the right.
+   * 3. Orientation of intersected edges in each pair of (intersected edge, intersected triangle): a. the intersected edge of mesh A is directed from negative half-space of the intersected triangle from mesh B to its positive half-space, b. the intersected edge of mesh B is directed from positive half-space of the intersected triangle from mesh A to its negative half-space.
+   * 4. Orientation of contours: a. left of contours on mesh A is inside of mesh B (consequence of 3a), b. right of contours on mesh B is inside of mesh A (consequence of 3b).
+   */
+  orderIntersectionContours(topologyA: MeshTopology, topologyB: MeshTopology, intersections: PreciseCollisionResult): ContinuousContours;
   CascadeMode: {Sequential: CascadeModeValue<0>, AABBTreeBased: CascadeModeValue<1>};
   MultiwayICPSamplingParameters: {
     new(): MultiwayICPSamplingParameters;
   };
   MultiwayICP: {
-    new(_0: any, _1: MultiwayICPSamplingParameters): MultiwayICP;
+    new(objects: readonly MeshOrPointsXf[], params: MultiwayICPSamplingParameters): MultiwayICP;
   };
+  DenoiseViaNormalsSettings: {
+    new(): DenoiseViaNormalsSettings;
+  };
+  /**
+   * Reduces noise in given mesh, see the article "Mesh Denoising via a Novel Mumford-Shah Framework"
+   */
+  meshDenoiseViaNormals(mesh: Mesh | null): void;
+  /**
+   * Reduces noise in given mesh, see the article "Mesh Denoising via a Novel Mumford-Shah Framework"
+   */
+  meshDenoiseViaNormals(mesh: Mesh | null, settings: DenoiseViaNormalsSettings): void;
   BaseShellParameters: {
     new(): BaseShellParameters;
   };
@@ -773,55 +2124,176 @@ interface EmbindModule {
   GeneralOffsetParameters: {
     new(): GeneralOffsetParameters;
   };
-  suggestVoxelSize(_0: Mesh | null, _1: number): number;
-  offsetMesh(_0: Mesh | null, _1: number, _2: OffsetParameters): Mesh | null;
-  doubleOffsetMesh(_0: Mesh | null, _1: number, _2: number, _3: OffsetParameters): Mesh | null;
-  mcOffsetMesh(_0: Mesh | null, _1: number, _2: OffsetParameters): Mesh | null;
-  mcShellMeshRegion(_0: Mesh | null, _1: FaceBitSet, _2: number, _3: BaseShellParameters): Mesh | null;
-  sharpOffsetMesh(_0: Mesh | null, _1: number, _2: SharpOffsetParameters): Mesh | null;
-  generalOffsetMesh(_0: Mesh | null, _1: number, _2: GeneralOffsetParameters): Mesh | null;
-  thickenMesh(_0: Mesh | null, _1: number, _2: GeneralOffsetParameters): Mesh | null;
+  /**
+   * @brief computes size of a cubical voxel to get approximately given number of voxels during rasterization
+   */
+  suggestVoxelSize(mp: Mesh | null, approxNumVoxels: number): number;
+  /**
+   * Offsets mesh by converting it to distance field in voxels using OpenVDB library, signDetectionMode = Unsigned(from OpenVDB) | OpenVDB | HoleWindingRule, and then converts back using OpenVDB library (dual marching cubes), so result mesh is always closed
+   */
+  offsetMesh(mp: Mesh | null, offset: number, params: OffsetParameters): Mesh | null;
+  /**
+   * Offsets mesh by converting it to voxels and back two times only closed meshes allowed (only Offset mode) typically offsetA and offsetB have distinct signs
+   */
+  doubleOffsetMesh(mp: Mesh | null, offsetA: number, offsetB: number, params: OffsetParameters): Mesh | null;
+  /**
+   * Offsets mesh by converting it to distance field in voxels (using OpenVDB library if SignDetectionMode::OpenVDB or our implementation otherwise) and back using standard Marching Cubes, as opposed to Dual Marching Cubes in offsetMesh(...)
+   */
+  mcOffsetMesh(mp: Mesh | null, offset: number, params: OffsetParameters): Mesh | null;
+  /**
+   * Constructs a shell around selected mesh region with the properties that every point on the shall must
+   * 1. be located not further than given distance from selected mesh part,
+   * 2. be located not closer to not-selected mesh part than to selected mesh part.
+   */
+  mcShellMeshRegion(mesh: Mesh | null, region: FaceBitSet, offset: number, params: BaseShellParameters): Mesh | null;
+  /**
+   * Offsets mesh by converting it to voxels and back post process result using reference mesh to sharpen features
+   */
+  sharpOffsetMesh(mp: Mesh | null, offset: number, params: SharpOffsetParameters): Mesh | null;
+  /**
+   * Offsets mesh by converting it to voxels and back using one of three modes specified in the parameters
+   */
+  generalOffsetMesh(mp: Mesh | null, offset: number, params: GeneralOffsetParameters): Mesh | null;
+  /**
+   * @brief mapping between original mesh and thicken result
+   *
+   * in case of positive offset, returns the mesh consisting of offset mesh merged with inversed original mesh (thickening mode); in case of negative offset, returns the mesh consisting of inversed offset mesh merged with original mesh (hollowing mode); if your input mesh is open then please specify params.signDetectionMode = SignDetectionMode::Unsigned, and you will get open mesh (with several components) on output if your input mesh is closed then please specify another sign detection mode, and you will get closed mesh (with several components) on output;
+   */
+  thickenMesh(mesh: Mesh | null, offset: number, params: GeneralOffsetParameters): Mesh | null;
   OneMeshContours: {};
-  cutMesh(_0: Mesh | null, _1: OneMeshContours, _2: CutMeshParameters): any;
+  /**
+   * @brief Cuts mesh by given contours.
+   *
+   * This function cuts mesh making new edges paths on place of input contours @param mesh Input mesh that will be cut
+   * @param contours Input contours to cut mesh with, find more MR::OneMeshContours
+   * @param params Parameters describing some cut options, find more MR::CutMeshParameters
+   *
+   * @returns New edges that correspond to given contours, find more MR::CutMeshResult
+   *
+   * @warning Input contours should have no intersections, faces where contours intersects (`bad faces`) will not be allowed for fill
+   *
+   * @warning Input mesh will be changed in any case, if `bad faces` are in mesh, mesh will be spoiled,
+   * so if you cannot guarantee contours without intersections better make copy of mesh, before using this function
+   */
+  cutMesh(mesh: Mesh | null, contours: OneMeshContours, params: CutMeshParameters): CutMeshResult;
   PointCloud: {
     new(): PointCloud;
   };
-  makeConvexHullFromPoints(_0: PointCloud): Mesh | null;
-  meshToPointCloud(_0: Mesh | null, _1: boolean): PointCloud;
+  makeConvexHullFromPoints(pointCloud: PointCloud): Mesh | null;
+  /**
+   * Mesh to PointCloud
+   */
+  meshToPointCloud(mesh: Mesh | null, saveNormals: boolean): PointCloud;
+  /**
+   * @brief Finds the radius of ball, so on average that ball contained avgPoints excluding the central point.
+   *
+   * @param samples the number of test points to find given number of samples in each
+   */
+  findAvgPointsRadius(pointCloud: PointCloud, avgPoints: number): number;
+  /**
+   * @brief Finds the radius of ball, so on average that ball contained avgPoints excluding the central point.
+   *
+   * @param samples the number of test points to find given number of samples in each
+   */
+  findAvgPointsRadius(pointCloud: PointCloud, avgPoints: number, samples: number): number;
   TriangulationParameters: {
     new(): TriangulationParameters;
   };
-  triangulatePointCloud(_0: PointCloud, _1: TriangulationParameters): Mesh | null;
+  /**
+   * @brief Creates mesh from given point cloud according params Returns empty optional if was interrupted by progress bar.
+   */
+  triangulatePointCloud(pointCloud: PointCloud, params: TriangulationParameters): Mesh | null;
   PointsLoad: {
-    fromAnySupportedFormat(_0: EmbindString): PointCloud;
+    /**
+     * @brief detects the format from file extension and loads points from it
+     */
+    fromAnySupportedFormat(path: EmbindString): PointCloud;
   };
   PointsSave: {
-    toAnySupportedFormat(_0: PointCloud, _1: EmbindString): void;
+    /**
+     * @brief detects the format from file extension and save points to it
+     */
+    toAnySupportedFormat(points: PointCloud, path: EmbindString): void;
+  };
+  PointsToMeshParameters: {
+    new(): PointsToMeshParameters;
   };
+  /**
+   * makes mesh from points with normals by constructing intermediate volume with signed distances and then using marching cubes algorithm to extract the surface from there
+   */
+  pointsToMeshFusion(cloud: PointCloud, params: PointsToMeshParameters): Mesh | null;
   MeshProjectionParameters: {
     new(): MeshProjectionParameters;
   };
-  findSignedDistances(_0: Mesh | null, _1: Mesh | null, _2: MeshProjectionParameters): any;
+  /**
+   * @brief if projector is not given then CPU's computations will be used
+   *
+   * Computes signed distances from given test points to the closest point on the reference mesh: positive value - outside reference mesh, negative - inside reference mesh; this method can return wrong sign if the closest point is located on self-intersecting part of the mesh
+   */
+  findSignedDistances(refMesh: Mesh | null, mesh: Mesh | null, params: MeshProjectionParameters): Float32Array;
   CoordinateConverters: {};
-  getVectorConverters(_0: Mesh, _1: Mesh): CoordinateConverters;
-  findCollidingEdgeTrisPrecise(_0: Mesh, _1: Mesh, _2: CoordinateConverters): PreciseCollisionResult;
-  getOneMeshIntersectionContours(_0: Mesh, _1: Mesh, _2: ContinuousContours, _3: boolean, _4: CoordinateConverters): OneMeshContours;
-  getIncidentVertsFromFaces(_0: MeshTopology, _1: FaceBitSet): VertBitSet;
-  getIncidentVertsFromEdges(_0: MeshTopology, _1: UndirectedEdgeBitSet): VertBitSet;
-  getIncidentFacesFromVerts(_0: MeshTopology, _1: VertBitSet): FaceBitSet;
-  getIncidentFacesFromEdges(_0: MeshTopology, _1: UndirectedEdgeBitSet): FaceBitSet;
-  getIncidentEdgesFromFaces(_0: MeshTopology, _1: FaceBitSet): UndirectedEdgeBitSet;
-  getIncidentEdgesFromEdges(_0: MeshTopology, _1: UndirectedEdgeBitSet): UndirectedEdgeBitSet;
-  getInnerVertsFromFaces(_0: MeshTopology, _1: FaceBitSet): VertBitSet;
-  getInnerVertsFromEdges(_0: MeshTopology, _1: UndirectedEdgeBitSet): VertBitSet;
-  getInnerFaces(_0: MeshTopology, _1: VertBitSet): FaceBitSet;
-  getInnerEdgesFromVerts(_0: MeshTopology, _1: VertBitSet): UndirectedEdgeBitSet;
-  getInnerEdgesFromFaces(_0: MeshTopology, _1: FaceBitSet): UndirectedEdgeBitSet;
-  getBoundaryVerts(_0: MeshTopology, _1: FaceBitSet): VertBitSet;
-  trackRightBoundaryLoop(_0: MeshTopology, _1: number): any;
-  findRightBoundary(_0: MeshTopology): any;
+  /**
+   * @brief creates simple converters from Vector3f to Vector3i and back in mesh parts area range
+   *
+   * @param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
+   */
+  getVectorConverters(a: Mesh, b: Mesh): CoordinateConverters;
+  /**
+   * @brief finds all pairs of colliding edges from one mesh and triangle from another mesh
+   *
+   * @param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
+   * @param anyIntersection if true then the function returns as fast as it finds any intersection
+   */
+  findCollidingEdgeTrisPrecise(a: Mesh, b: Mesh, conv: CoordinateConverters): PreciseCollisionResult;
+  /**
+   * @brief if true, then open self-intersection contours will be prolonged to terminal vertices
+   *
+   * Converts contours given in topological terms as the intersections of one mesh's edge and another mesh's triangle (ContinuousContours), into contours of meshA and/or meshB given as a sequence of (primitiveId and Cartesian coordinates); converters are required for better precision in case of degenerations; note that contours should not have intersections
+   */
+  getOneMeshIntersectionContours(meshA: Mesh, meshB: Mesh, contours: ContinuousContours, getMeshAIntersections: boolean, converters: CoordinateConverters): OneMeshContours;
+  getIncidentVertsFromFaces(topology: MeshTopology, faces: FaceBitSet): VertBitSet;
+  getIncidentVertsFromEdges(topology: MeshTopology, edges: UndirectedEdgeBitSet): VertBitSet;
+  getIncidentFacesFromVerts(topology: MeshTopology, verts: VertBitSet): FaceBitSet;
+  getIncidentFacesFromEdges(topology: MeshTopology, edges: UndirectedEdgeBitSet): FaceBitSet;
+  getIncidentEdgesFromFaces(topology: MeshTopology, faces: FaceBitSet): UndirectedEdgeBitSet;
+  getIncidentEdgesFromEdges(topology: MeshTopology, edges: UndirectedEdgeBitSet): UndirectedEdgeBitSet;
+  getInnerVertsFromFaces(topology: MeshTopology, region: FaceBitSet): VertBitSet;
+  getInnerVertsFromEdges(topology: MeshTopology, edges: UndirectedEdgeBitSet): VertBitSet;
+  /**
+   * @brief composes the set of all faces with all their vertices in given set
+   */
+  getInnerFaces(topology: MeshTopology, verts: VertBitSet): FaceBitSet;
+  getInnerEdgesFromVerts(topology: MeshTopology, verts: VertBitSet): UndirectedEdgeBitSet;
+  getInnerEdgesFromFaces(topology: MeshTopology, region: FaceBitSet): UndirectedEdgeBitSet;
+  /**
+   * @brief composes the set of all boundary vertices for given region (or whole mesh if !region)
+   */
+  getBoundaryVerts(topology: MeshTopology, region: FaceBitSet): VertBitSet;
+  /**
+   * @brief same as above, but writes the loop in `outLoop` (cleared first), so a caller tracking many loops one by one reuses its capacity
+   */
+  trackRightBoundaryLoop(topology: MeshTopology, e0: number): Uint32Array;
+  /**
+   * returns all region boundary loops; every loop has region faces on the right, and not-region faces or holes on the left
+   */
+  findRightBoundary(topology: MeshTopology): Uint32Array[];
+  /**
+   * @brief how to determine the sign of distances from a mesh
+   */
   SignDetectionMode: {Unsigned: SignDetectionModeValue<0>, OpenVDB: SignDetectionModeValue<1>, ProjectionNormal: SignDetectionModeValue<2>, WindingRule: SignDetectionModeValue<3>, HoleWindingRule: SignDetectionModeValue<4>};
-  makeTorus(_0: number, _1: number, _2: number, _3: number): Mesh | null;
+  makeTorus(): Mesh | null;
+  makeTorus(primaryRadius: number): Mesh | null;
+  makeTorus(primaryRadius: number, secondaryRadius: number): Mesh | null;
+  makeTorus(primaryRadius: number, secondaryRadius: number, primaryResolution: number): Mesh | null;
+  makeTorus(primaryRadius: number, secondaryRadius: number, primaryResolution: number, secondaryResolution: number): Mesh | null;
+  makeTorusWithSelfIntersections(primaryRadius: number, secondaryRadius: number, primaryResolution: number, secondaryResolution: number): Mesh | null;
+  UniformSamplingSettings: {
+    new(): UniformSamplingSettings;
+  };
+  /**
+   * Sample vertices, removing ones that are too close; returns std::nullopt if it was terminated by the callback
+   */
+  pointUniformSampling(pointCloud: PointCloud, settings: UniformSamplingSettings): VertBitSet;
   MeshToVolumeType: {Signed: MeshToVolumeTypeValue<0>, Unsigned: MeshToVolumeTypeValue<1>};
   MeshToVolumeParams: {
     new(): MeshToVolumeParams;
@@ -829,45 +2301,106 @@ interface EmbindModule {
   GridToMeshSettings: {
     new(): GridToMeshSettings;
   };
-  evalGridMinMax(_0: FloatGrid): any;
-  gridToMesh(_0: FloatGrid, _1: GridToMeshSettings): Mesh | null;
+  evalGridMinMax(grid: FloatGrid): GridMinMax;
+  /**
+   * @brief converts OpenVDB Grid into mesh using Dual Marching Cubes algorithm
+   */
+  gridToMesh(grid: FloatGrid, settings: GridToMeshSettings): Mesh | null;
   VdbVolume: {};
-  meshToVolume(_0: Mesh | null, _1: MeshToVolumeParams): VdbVolume;
-  meshToDistanceVdbVolume(_0: Mesh | null, _1: MeshToVolumeParams): VdbVolume;
-  floatGridToVdbVolume(_0: FloatGrid): VdbVolume;
+  /**
+   * converts mesh (or its part) into a volume filled with signed or unsigned distances to mesh using OpenVDB library; for signed distances the mesh must be closed; prior to conversion, world space is shifted to ensure that the bounding box of offset mesh is in positive quarter-space, and the shift is written in *params.outXf
+   */
+  meshToVolume(mp: Mesh | null, params: MeshToVolumeParams): VdbVolume;
+  /**
+   * converts mesh (or its part) into a volume filled with signed or unsigned distances to mesh using OpenVDB library; for signed distances the mesh must be closed; *params.outXf is untouched
+   */
+  meshToDistanceVdbVolume(mp: Mesh | null, params: MeshToVolumeParams): VdbVolume;
+  floatGridToVdbVolume(grid: FloatGrid): VdbVolume;
   VertCoords: {
-    fromArray(_0: any): VertCoords;
+    fromArray(array: Float32Array): VertCoords;
+  };
+  /**
+   * @brief returns a vector with vertex normals in every element for valid mesh vertices
+   */
+  computePerVertNormals(mesh: Mesh | null): VertCoords;
+  VertScalars: {
+    fromArray(array: Float32Array): VertScalars;
   };
-  computePerVertNormals(_0: Mesh | null): VertCoords;
   Triangulation: {
-    fromArray(_0: any): Triangulation;
+    fromArray(array: Uint32Array): Triangulation;
   };
   FaceNormals: {
-    fromArray(_0: any): FaceNormals;
+    fromArray(array: Float32Array): FaceNormals;
   };
-  computePerFaceNormals(_0: Mesh | null): FaceNormals;
+  /**
+   * @brief returns a vector with face-normal in every element for valid mesh faces
+   */
+  computePerFaceNormals(mesh: Mesh | null): FaceNormals;
   VertMap: {
-    fromArray(_0: any): VertMap;
+    fromArray(array: Uint32Array): VertMap;
   };
   FaceMap: {
-    fromArray(_0: any): FaceMap;
+    fromArray(array: Uint32Array): FaceMap;
   };
   Face2RegionMap: {
-    fromArray(_0: any): Face2RegionMap;
+    fromArray(array: Uint32Array): Face2RegionMap;
   };
   VertColors: {
-    fromArray(_0: any): VertColors;
+    fromArray(array: Uint8Array): VertColors;
+  };
+  /**
+   * creates box mesh with given min-corner (base) and given size in every dimension; with default parameters, creates unit cube mesh with the centroid in (0,0,0)
+   */
+  makeCube(size: Vector3f): Mesh | null;
+  /**
+   * creates box mesh with given min-corner (base) and given size in every dimension; with default parameters, creates unit cube mesh with the centroid in (0,0,0)
+   */
+  makeCube(size: Vector3f, base: Vector3f): Mesh | null;
+  /**
+   * @brief computes the closest point on mesh (or its region) to given point
+   *
+   * @param upDistLimitSq upper limit on the distance in question, if the real distance is larger then the function exits returning upDistLimitSq and no valid point
+   * @param xf mesh-to-point transformation, if not specified then identity transformation is assumed
+   * @param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one
+   * @param validFaces if provided then only faces from there will be considered as projections
+   * @param validProjections if provided then only projections passed this test can be returned
+   */
+  findProjection(pt: Vector3f, mp: Mesh | null): MeshProjectionResult;
+  findSignedDistanceFromPoint(pt: Vector3f, mp: Mesh | null): SignedMeshProjectionResult;
+  /**
+   * @brief returns the value at given voxel
+   */
+  getValue(grid: FloatGrid, p: Vector3i): number;
+  /**
+   * sets given region voxels value @note region is in grid space (0 voxel id is minimum active voxel in grid)
+   */
+  setValue(grid: FloatGrid, p: Vector3i, value: number): void;
+  Vector3: {
+    plusZ(): Vector3f;
+    diagonal(a: number): Vector3f;
+    add(a: Vector3f, b: Vector3f): Vector3f;
+    mulScalar(v: Vector3f, s: number): Vector3f;
   };
-  makeCube(_0: Vector3f, _1: Vector3f): Mesh | null;
-  findProjection(_0: Vector3f, _1: Mesh | null): any;
-  findSignedDistance(_0: Vector3f, _1: Mesh | null): any;
-  getValue(_0: FloatGrid, _1: Vector3i): number;
-  setValue(_0: FloatGrid, _1: Vector3i, _2: number): void;
   VoxelsLoad: {
-    fromAnySupportedFormat(_0: EmbindString): any;
+    /**
+     * @brief Detects the format from file extension and loads voxels from it.
+     */
+    fromAnySupportedFormat(path: EmbindString): VdbVolume[];
   };
   VoxelsSave: {
-    toAnySupportedFormat(_0: VdbVolume, _1: EmbindString): void;
+    toAnySupportedFormat(volume: VdbVolume, path: EmbindString): void;
+  };
+  WeightedShellParametersBase: {
+    new(): WeightedShellParametersBase;
+  };
+  WeightedShellParametersMetric: {
+    new(): WeightedShellParametersMetric;
+  };
+  WeightedShell: {
+    /**
+     * consider a mesh where each vertex has additive weight, and this weight is linearly interpolated in mesh triangles, and the distance to a point is considered equal to (euclidean distance - weight), constructs iso-surface of such distance field corresponding to params.offset value using marching cubes
+     */
+    meshShell(mesh: Mesh | null, vertWeights: VertScalars, params: WeightedShellParametersMetric): Mesh | null;
   };
 }