@meshinspector/meshlib 1.0.0-5638

package/bindings.d.mts

@@ -0,0 +1,875 @@
+// TypeScript bindings for emscripten-generated code.  Automatically generated at compile time.
+interface WasmModule {
+  __ZdlPvm(_0: number, _1: number): void;
+  _main(_0: number, _1: number): number;
+  __ZdaPv(_0: number): void;
+  _emsGetPointerSize(): number;
+  __ZdaPvm(_0: number, _1: number): void;
+  __ZdlPv(_0: number): void;
+  _emscripten_builtin_malloc(_0: number): number;
+  ___libc_malloc(_0: number): number;
+  _strndup(_0: number, _1: number): number;
+  __Znaj(_0: number): number;
+  __ZnajSt11align_val_t(_0: number, _1: number): number;
+  __Znwj(_0: number): number;
+  __ZnwjSt11align_val_t(_0: number, _1: number): number;
+  ___libc_calloc(_0: number, _1: number): number;
+  ___libc_free(_0: number): void;
+  ___libc_realloc(_0: number, _1: number): number;
+  _emscripten_builtin_calloc(_0: number, _1: number): number;
+  _emscripten_builtin_free(_0: number): void;
+  _emscripten_builtin_realloc(_0: number, _1: number): number;
+  _malloc_size(_0: number): number;
+  _malloc_usable_size(_0: number): number;
+  _reallocf(_0: number, _1: number): number;
+}
+
+type EmbindString = ArrayBuffer|Uint8Array|Uint8ClampedArray|Int8Array|string;
+export interface ClassHandle {
+  isAliasOf(other: ClassHandle): boolean;
+  delete(): void;
+  deleteLater(): this;
+  isDeleted(): boolean;
+  // @ts-ignore - If targeting lower than ESNext, this symbol might not exist.
+  [Symbol.dispose](): void;
+  clone(): this;
+}
+export interface AffineXf3f extends ClassHandle {
+  A: Matrix3f;
+  b: Vector3f;
+  mul(_0: AffineXf3f): AffineXf3f;
+  apply(_0: Vector3f): Vector3f;
+}
+
+export interface BitSet extends ClassHandle {
+  size(): number;
+  count(): number;
+  empty(): boolean;
+  test(_0: number): boolean;
+  toIndices(): any;
+}
+
+export interface FaceBitSet extends BitSet {
+}
+
+export interface VertBitSet extends BitSet {
+}
+
+export interface EdgeBitSet extends BitSet {
+}
+
+export interface UndirectedEdgeBitSet extends BitSet {
+}
+
+export interface Box3f extends ClassHandle {
+  min: Vector3f;
+  max: Vector3f;
+  valid(): boolean;
+  diagonal(): number;
+  volume(): number;
+  size(): Vector3f;
+  center(): Vector3f;
+}
+
+export interface Box3i extends ClassHandle {
+  min: Vector3i;
+  max: Vector3i;
+  valid(): boolean;
+  volume(): number;
+  size(): Vector3i;
+}
+
+export type Color = {
+  r: number,
+  g: number,
+  b: number,
+  a: number
+};
+
+export interface FillPartValue<T extends number> {
+  value: T;
+}
+export type FillPart = FillPartValue<0>|FillPartValue<1>|FillPartValue<2>;
+
+export interface ForceFillValue<T extends number> {
+  value: T;
+}
+export type ForceFill = ForceFillValue<0>|ForceFillValue<1>|ForceFillValue<2>;
+
+export interface CutMeshParameters extends ClassHandle {
+  fillPart: FillPart;
+  forceFillMode: ForceFill;
+}
+
+export interface CutByProjectionSettings extends ClassHandle {
+  direction: Vector3f;
+}
+
+export interface EdgeWeightsValue<T extends number> {
+  value: T;
+}
+export type EdgeWeights = EdgeWeightsValue<0>|EdgeWeightsValue<1>;
+
+export interface VertexMassValue<T extends number> {
+  value: T;
+}
+export type VertexMass = VertexMassValue<0>|VertexMassValue<1>;
+
+export interface RememberShapeValue<T extends number> {
+  value: T;
+}
+export type RememberShape = RememberShapeValue<0>|RememberShapeValue<1>;
+
+export interface OffsetModeValue<T extends number> {
+  value: T;
+}
+export type OffsetMode = OffsetModeValue<0>|OffsetModeValue<1>|OffsetModeValue<2>;
+
+export interface SubdivideFillingSettings extends ClassHandle {
+  maxEdgeLen: number;
+  maxEdgeSplits: number;
+  maxAngleChangeAfterFlip: number;
+}
+
+export interface SmoothFillingSettings extends ClassHandle {
+  naturalSmooth: boolean;
+  edgeWeights: EdgeWeights;
+  vmass: VertexMass;
+}
+
+export interface FillHoleNicelySettings extends ClassHandle {
+  triangulateOnly: boolean;
+  subdivideSettings: SubdivideFillingSettings;
+  smoothCurvature: boolean;
+  smoothSettings: SmoothFillingSettings;
+  triangulateParams: FillHoleParams;
+}
+
+export interface SelfIntersectionsMethodValue<T extends number> {
+  value: T;
+}
+export type SelfIntersectionsMethod = SelfIntersectionsMethodValue<0>|SelfIntersectionsMethodValue<1>;
+
+export interface SelfIntersectionsSettings extends ClassHandle {
+  touchIsIntersection: boolean;
+  method: SelfIntersectionsMethod;
+  relaxIterations: number;
+  maxExpand: number;
+  subdivideEdgeLen: number;
+  mimicPatch: boolean;
+  callback: any;
+}
+
+export interface SelfIntersections extends ClassHandle {
+}
+
+export interface FloatGrid extends ClassHandle {
+}
+
+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;
+}
+
+export interface ICPMethodValue<T extends number> {
+  value: T;
+}
+export type ICPMethod = ICPMethodValue<0>|ICPMethodValue<1>|ICPMethodValue<2>;
+
+export interface ICPModeValue<T extends number> {
+  value: T;
+}
+export type ICPMode = ICPModeValue<0>|ICPModeValue<1>|ICPModeValue<2>|ICPModeValue<3>|ICPModeValue<4>;
+
+export interface ICPExitTypeValue<T extends number> {
+  value: T;
+}
+export type ICPExitType = ICPExitTypeValue<0>|ICPExitTypeValue<1>|ICPExitTypeValue<2>|ICPExitTypeValue<3>|ICPExitTypeValue<4>;
+
+export interface ICPProperties extends ClassHandle {
+  method: ICPMethod;
+  p2plAngleLimit: number;
+  p2plScaleLimit: number;
+  cosThreshold: number;
+  distThresholdSq: number;
+  farDistFactor: number;
+  icpMode: ICPMode;
+  iterLimit: number;
+  badIterStopCount: number;
+  exitVal: number;
+  mutualClosest: boolean;
+  ignoreBdTgts: boolean;
+  fixedRotationAxis: Vector3f;
+}
+
+export interface ICP extends ClassHandle {
+  setParams(_0: ICPProperties): void;
+  samplePoints(_0: number): void;
+  autoSelectFloatXf(): AffineXf3f;
+  updatePointPairs(): void;
+  getStatusInfo(): string;
+  getNumSamples(): number;
+  getNumActivePairs(): number;
+  getMeanSqDistToPoint(): number;
+  getMeanSqDistToPlane(): number;
+  calculateTransformation(): AffineXf3f;
+}
+
+export interface ContinuousContours extends ClassHandle {
+}
+
+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;
+  apply(): void;
+  fixVertex(_0: number, _1: Vector3f, _2: boolean): void;
+}
+
+export type SphereParams = {
+  radius: number,
+  numMeshVertices: number
+};
+
+export interface Matrix3f extends ClassHandle {
+  x: Vector3f;
+  y: Vector3f;
+  z: Vector3f;
+}
+
+export interface Mesh extends ClassHandle {
+  readonly topology: MeshTopology;
+  readonly points: VertCoords;
+  pack(): void;
+  volume(): number;
+  area(): number;
+  computeBoundingBox(): Box3f;
+  invalidateCaches(): void;
+  transform(_0: AffineXf3f): void;
+  averageEdgeLength(): number;
+  addMesh(_0: Mesh | null): void;
+  edgeLength(_0: number): number;
+  edgeLengthSq(_0: number): number;
+  findCenterFromPoints(): Vector3f;
+  findCenterFromFaces(): Vector3f;
+  findCenterFromBBox(): Vector3f;
+  toTriPoint(_0: number, _1: Vector3f): any;
+}
+
+export interface BooleanOperationValue<T extends number> {
+  value: T;
+}
+export type BooleanOperation = BooleanOperationValue<0>|BooleanOperationValue<1>|BooleanOperationValue<2>|BooleanOperationValue<3>|BooleanOperationValue<4>|BooleanOperationValue<5>|BooleanOperationValue<6>|BooleanOperationValue<7>;
+
+export interface BooleanResult extends ClassHandle {
+  get errorString(): string;
+  set errorString(value: EmbindString);
+  readonly mesh: Mesh | null;
+  valid(): boolean;
+}
+
+export interface BooleanMapObjectValue<T extends number> {
+  value: T;
+}
+export type BooleanMapObject = BooleanMapObjectValue<0>|BooleanMapObjectValue<1>;
+
+export interface BooleanResultMapper extends ClassHandle {
+  mapFaces(_0: FaceBitSet, _1: BooleanMapObject): FaceBitSet;
+  mapVerts(_0: VertBitSet, _1: BooleanMapObject): VertBitSet;
+  newFaces(): FaceBitSet;
+  filteredOldFaceBitSet(_0: FaceBitSet, _1: BooleanMapObject): FaceBitSet;
+  getNew2OldFaceMap(_0: BooleanMapObject): FaceMap;
+}
+
+export interface MeshBuilder extends ClassHandle {
+}
+
+export interface PreciseCollisionResult extends ClassHandle {
+}
+
+export interface MeshComponentsFaceIncidenceValue<T extends number> {
+  value: T;
+}
+export type MeshComponentsFaceIncidence = MeshComponentsFaceIncidenceValue<0>|MeshComponentsFaceIncidenceValue<1>;
+
+export interface MeshComponents extends ClassHandle {
+}
+
+export interface DecimateStrategyValue<T extends number> {
+  value: T;
+}
+export type DecimateStrategy = DecimateStrategyValue<0>|DecimateStrategyValue<1>;
+
+export type DecimateResult = {
+  vertsDeleted: number,
+  facesDeleted: number,
+  errorIntroduced: number,
+  cancelled: boolean
+};
+
+export interface DecimateSettings extends ClassHandle {
+  strategy: DecimateStrategy;
+  maxError: number;
+  maxEdgeLen: number;
+  maxBdShift: number;
+  maxTriangleAspectRatio: number;
+  criticalTriAspectRatio: number;
+  tinyEdgeLength: number;
+  stabilizer: number;
+  angleWeightedDistToPlane: boolean;
+  optimizeVertexPos: boolean;
+  maxDeletedVertices: number;
+  maxDeletedFaces: number;
+  collapseNearNotFlippable: boolean;
+  touchNearBdEdges: boolean;
+  touchBdVerts: boolean;
+  maxAngleChange: number;
+  packMesh: boolean;
+  subdivideParts: number;
+  decimateBetweenParts: boolean;
+  minFacesInPart: number;
+}
+
+export interface RemeshSettings extends ClassHandle {
+  targetEdgeLen: number;
+  maxEdgeSplits: number;
+  maxAngleChangeAfterFlip: number;
+  frozenBoundary: boolean;
+  maxBdShift: number;
+  useCurvature: boolean;
+  maxSplittableTriAspectRatio: number;
+  finalRelaxIters: number;
+  finalRelaxNoShrinkage: boolean;
+  packMesh: boolean;
+  projectOnOriginalMesh: boolean;
+}
+
+export interface MultipleEdgesResolveModeValue<T extends number> {
+  value: T;
+}
+export type MultipleEdgesResolveMode = MultipleEdgesResolveModeValue<0>|MultipleEdgesResolveModeValue<1>|MultipleEdgesResolveModeValue<2>;
+
+export interface FillHoleParams extends ClassHandle {
+  smoothBd: boolean;
+  multipleEdgesResolveMode: MultipleEdgesResolveMode;
+  makeDegenerateBand: boolean;
+  maxPolygonSubdivisions: number;
+}
+
+export interface FixMeshDegeneraciesModeValue<T extends number> {
+  value: T;
+}
+export type FixMeshDegeneraciesMode = FixMeshDegeneraciesModeValue<0>|FixMeshDegeneraciesModeValue<1>|FixMeshDegeneraciesModeValue<2>;
+
+export interface FixMeshDegeneraciesParams extends ClassHandle {
+  maxDeviation: number;
+  tinyEdgeLength: number;
+  criticalTriAspectRatio: number;
+  maxAngleChange: number;
+  stabilizer: number;
+  mode: FixMeshDegeneraciesMode;
+  mimicPatch: boolean;
+}
+
+export interface MeshLoad extends ClassHandle {
+}
+
+export interface FillHoleMetric extends ClassHandle {
+}
+
+export interface MeshOrPoints extends ClassHandle {
+}
+
+export interface MeshOrPointsXf extends ClassHandle {
+  xf: AffineXf3f;
+}
+
+export interface MeshRelaxParams extends ClassHandle {
+  iterations: number;
+  force: number;
+  limitNearInitial: boolean;
+  maxInitialDist: number;
+  hardSmoothTetrahedrons: boolean;
+}
+
+export interface MeshSave extends ClassHandle {
+}
+
+export interface MeshTopology extends ClassHandle {
+  getValidVerts(): VertBitSet;
+  getValidFaces(): FaceBitSet;
+  faceSize(): number;
+  findNumHoles(): number;
+  getTriVerts(_0: number): any;
+  getLeftTriVerts(_0: number): any;
+  findHoleRepresentiveEdges(): any;
+  getTriangulation(): Triangulation;
+}
+
+export interface CascadeModeValue<T extends number> {
+  value: T;
+}
+export type CascadeMode = CascadeModeValue<0>|CascadeModeValue<1>;
+
+export interface MultiwayICPSamplingParameters extends ClassHandle {
+  samplingVoxelSize: number;
+  maxGroupSize: number;
+  cascadeMode: CascadeMode;
+}
+
+export interface MultiwayICP extends ClassHandle {
+  calculateTransformations(): any;
+  resamplePoints(_0: MultiwayICPSamplingParameters): boolean;
+  updateAllPointPairs(): boolean;
+  setParams(_0: ICPProperties): void;
+  getParams(): ICPProperties;
+  getMeanSqDistToPoint(): number;
+  getMeanSqDistToPlane(): number;
+  getNumSamples(): number;
+  getNumActivePairs(): number;
+  getStatusInfo(): string;
+}
+
+export interface BaseShellParameters extends ClassHandle {
+  voxelSize: number;
+}
+
+export interface OffsetParameters extends BaseShellParameters {
+  memoryEfficient: boolean;
+  signDetectionMode: SignDetectionMode;
+}
+
+export interface SharpOffsetParameters extends OffsetParameters {
+  minNewVertDev: number;
+  maxNewRank2VertDev: number;
+  maxNewRank3VertDev: number;
+  maxOldVertPosCorrection: number;
+}
+
+export interface GeneralOffsetParameters extends SharpOffsetParameters {
+  mode: OffsetMode;
+}
+
+export interface OneMeshContours extends ClassHandle {
+}
+
+export interface PointCloud extends ClassHandle {
+  readonly validPoints: VertBitSet;
+  readonly points: VertCoords;
+  readonly normals: VertCoords;
+  computeBoundingBox(): Box3f;
+  addPoint(_0: Vector3f): number;
+}
+
+export interface TriangulationParameters extends ClassHandle {
+  numNeighbours: number;
+  radius: number;
+  critAngle: number;
+  critHoleLength: number;
+  automaticRadiusIncrease: boolean;
+}
+
+export interface PointsLoad extends ClassHandle {
+}
+
+export interface PointsSave extends ClassHandle {
+}
+
+export interface MeshProjectionParameters extends ClassHandle {
+  loDistLimitSq: number;
+  upDistLimitSq: number;
+}
+
+export interface CoordinateConverters extends ClassHandle {
+}
+
+export interface SignDetectionModeValue<T extends number> {
+  value: T;
+}
+export type SignDetectionMode = SignDetectionModeValue<0>|SignDetectionModeValue<1>|SignDetectionModeValue<2>|SignDetectionModeValue<3>|SignDetectionModeValue<4>;
+
+export interface MeshToVolumeTypeValue<T extends number> {
+  value: T;
+}
+export type MeshToVolumeType = MeshToVolumeTypeValue<0>|MeshToVolumeTypeValue<1>;
+
+export interface MeshToVolumeParams extends ClassHandle {
+  type: MeshToVolumeType;
+  surfaceOffset: number;
+  worldXf: AffineXf3f;
+  voxelSize: Vector3f;
+}
+
+export interface GridToMeshSettings extends ClassHandle {
+  isoValue: number;
+  adaptivity: number;
+  maxFaces: number;
+  maxVertices: number;
+  relaxDisorientedTriangles: boolean;
+  voxelSize: Vector3f;
+}
+
+export interface VdbVolume extends ClassHandle {
+  readonly data: FloatGrid;
+  readonly min: number;
+  readonly max: number;
+  readonly voxelSize: Vector3f;
+  readonly dims: Vector3i;
+}
+
+export interface VertCoords extends ClassHandle {
+  toArray(): any;
+}
+
+export interface Triangulation extends ClassHandle {
+  toArray(): any;
+}
+
+export interface FaceNormals extends ClassHandle {
+  toArray(): any;
+}
+
+export interface VertMap extends ClassHandle {
+  toArray(): any;
+}
+
+export interface FaceMap extends ClassHandle {
+  toArray(): any;
+}
+
+export interface Face2RegionMap extends ClassHandle {
+  toArray(): any;
+}
+
+export interface VertColors extends ClassHandle {
+  toArray(): any;
+}
+
+export type Vector3f = {
+  x: number,
+  y: number,
+  z: number
+};
+
+export type Vector3i = {
+  x: number,
+  y: number,
+  z: number
+};
+
+export interface VoxelsLoad extends ClassHandle {
+}
+
+export interface VoxelsSave extends ClassHandle {
+}
+
+interface EmbindModule {
+  AffineXf3f: {
+    new(): AffineXf3f;
+    new(_0: Matrix3f, _1: Vector3f): AffineXf3f;
+    linear(_0: Matrix3f): AffineXf3f;
+    translation(_0: Vector3f): AffineXf3f;
+  };
+  BitSet: {
+    new(): BitSet;
+    fromIndices(_0: any): BitSet;
+  };
+  FaceBitSet: {
+    new(): FaceBitSet;
+    fromIndices(_0: any): FaceBitSet;
+  };
+  VertBitSet: {
+    new(): VertBitSet;
+    fromIndices(_0: any): VertBitSet;
+  };
+  EdgeBitSet: {
+    new(): EdgeBitSet;
+    fromIndices(_0: any): EdgeBitSet;
+  };
+  UndirectedEdgeBitSet: {
+    new(): UndirectedEdgeBitSet;
+    fromIndices(_0: any): UndirectedEdgeBitSet;
+  };
+  Box3f: {
+    new(): Box3f;
+    new(_0: Vector3f, _1: Vector3f): Box3f;
+  };
+  Box3i: {
+    new(): Box3i;
+    new(_0: Vector3i, _1: Vector3i): Box3i;
+  };
+  FillPart: {Both: FillPartValue<0>, Left: FillPartValue<1>, Right: FillPartValue<2>};
+  ForceFill: {None: ForceFillValue<0>, Good: ForceFillValue<1>, All: ForceFillValue<2>};
+  CutMeshParameters: {
+    new(): CutMeshParameters;
+  };
+  CutByProjectionSettings: {
+    new(): CutByProjectionSettings;
+  };
+  EdgeWeights: {Unit: EdgeWeightsValue<0>, Cotan: EdgeWeightsValue<1>};
+  VertexMass: {Unit: VertexMassValue<0>, NeiArea: VertexMassValue<1>};
+  RememberShape: {Yes: RememberShapeValue<0>, No: RememberShapeValue<1>};
+  OffsetMode: {Smooth: OffsetModeValue<0>, Standard: OffsetModeValue<1>, Sharpening: OffsetModeValue<2>};
+  SubdivideFillingSettings: {
+    new(): SubdivideFillingSettings;
+  };
+  SmoothFillingSettings: {
+    new(): SmoothFillingSettings;
+  };
+  FillHoleNicelySettings: {
+    new(): FillHoleNicelySettings;
+  };
+  SelfIntersectionsMethod: {Relax: SelfIntersectionsMethodValue<0>, CutAndFill: SelfIntersectionsMethodValue<1>};
+  SelfIntersectionsSettings: {
+    new(): SelfIntersectionsSettings;
+  };
+  SelfIntersections: {
+    getFaces(_0: Mesh, _1: boolean): FaceBitSet;
+    fix(_0: Mesh, _1: 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;
+  FreeFormDeformer: {
+    new(_0: Mesh | null): FreeFormDeformer;
+  };
+  ICPMethod: {Combined: ICPMethodValue<0>, PointToPoint: ICPMethodValue<1>, PointToPlane: ICPMethodValue<2>};
+  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;
+  };
+  ContinuousContours: {};
+  Laplacian: {
+    new(_0: Mesh | null): Laplacian;
+  };
+  Matrix3f: {
+    new(): Matrix3f;
+    new(_0: Vector3f, _1: Vector3f, _2: Vector3f): Matrix3f;
+    identity(): Matrix3f;
+    zero(): Matrix3f;
+    rotation(_0: Vector3f, _1: 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;
+  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;
+  BooleanMapObject: {A: BooleanMapObjectValue<0>, B: BooleanMapObjectValue<1>};
+  BooleanResultMapper: {
+    new(): BooleanResultMapper;
+  };
+  boolean(_0: Mesh | null, _1: Mesh | null, _2: BooleanOperation, _3: BooleanResultMapper): BooleanResult;
+  MeshBuilder: {
+    uniteCloseVertices(_0: Mesh | null, _1: number, _2: boolean): number;
+  };
+  isInside(_0: Mesh | null, _1: Mesh | null): boolean;
+  PreciseCollisionResult: {};
+  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;
+  };
+  DecimateStrategy: {MinimizeError: DecimateStrategyValue<0>, ShortestEdgeFirst: DecimateStrategyValue<1>};
+  DecimateSettings: {
+    new(): DecimateSettings;
+  };
+  decimateMesh(_0: Mesh | null, _1: DecimateSettings): DecimateResult;
+  RemeshSettings: {
+    new(): RemeshSettings;
+  };
+  remesh(_0: Mesh | null, _1: RemeshSettings): boolean;
+  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;
+  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;
+  MeshLoad: {
+    fromAnySupportedFormat(_0: EmbindString): Mesh | null;
+  };
+  findDistance(_0: Mesh | null, _1: Mesh | null): any;
+  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;
+  MeshOrPoints: {
+    fromMesh(_0: Mesh): MeshOrPoints;
+    fromPoints(_0: PointCloud): MeshOrPoints;
+  };
+  MeshOrPointsXf: {
+    new(_0: MeshOrPoints, _1: AffineXf3f): MeshOrPointsXf;
+  };
+  MeshRelaxParams: {
+    new(): MeshRelaxParams;
+  };
+  relax(_0: Mesh | null, _1: MeshRelaxParams): boolean;
+  relaxKeepVolume(_0: Mesh | null, _1: MeshRelaxParams): boolean;
+  MeshSave: {
+    toAnySupportedFormat(_0: Mesh | null, _1: EmbindString): void;
+  };
+  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;
+  CascadeMode: {Sequential: CascadeModeValue<0>, AABBTreeBased: CascadeModeValue<1>};
+  MultiwayICPSamplingParameters: {
+    new(): MultiwayICPSamplingParameters;
+  };
+  MultiwayICP: {
+    new(_0: any, _1: MultiwayICPSamplingParameters): MultiwayICP;
+  };
+  BaseShellParameters: {
+    new(): BaseShellParameters;
+  };
+  OffsetParameters: {
+    new(): OffsetParameters;
+  };
+  SharpOffsetParameters: {
+    new(): SharpOffsetParameters;
+  };
+  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;
+  OneMeshContours: {};
+  cutMesh(_0: Mesh | null, _1: OneMeshContours, _2: CutMeshParameters): any;
+  PointCloud: {
+    new(): PointCloud;
+  };
+  makeConvexHullFromPoints(_0: PointCloud): Mesh | null;
+  meshToPointCloud(_0: Mesh | null, _1: boolean): PointCloud;
+  TriangulationParameters: {
+    new(): TriangulationParameters;
+  };
+  triangulatePointCloud(_0: PointCloud, _1: TriangulationParameters): Mesh | null;
+  PointsLoad: {
+    fromAnySupportedFormat(_0: EmbindString): PointCloud;
+  };
+  PointsSave: {
+    toAnySupportedFormat(_0: PointCloud, _1: EmbindString): void;
+  };
+  MeshProjectionParameters: {
+    new(): MeshProjectionParameters;
+  };
+  findSignedDistances(_0: Mesh | null, _1: Mesh | null, _2: MeshProjectionParameters): any;
+  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;
+  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;
+  MeshToVolumeType: {Signed: MeshToVolumeTypeValue<0>, Unsigned: MeshToVolumeTypeValue<1>};
+  MeshToVolumeParams: {
+    new(): MeshToVolumeParams;
+  };
+  GridToMeshSettings: {
+    new(): GridToMeshSettings;
+  };
+  evalGridMinMax(_0: FloatGrid): any;
+  gridToMesh(_0: FloatGrid, _1: GridToMeshSettings): Mesh | null;
+  VdbVolume: {};
+  meshToVolume(_0: Mesh | null, _1: MeshToVolumeParams): VdbVolume;
+  meshToDistanceVdbVolume(_0: Mesh | null, _1: MeshToVolumeParams): VdbVolume;
+  floatGridToVdbVolume(_0: FloatGrid): VdbVolume;
+  VertCoords: {
+    fromArray(_0: any): VertCoords;
+  };
+  computePerVertNormals(_0: Mesh | null): VertCoords;
+  Triangulation: {
+    fromArray(_0: any): Triangulation;
+  };
+  FaceNormals: {
+    fromArray(_0: any): FaceNormals;
+  };
+  computePerFaceNormals(_0: Mesh | null): FaceNormals;
+  VertMap: {
+    fromArray(_0: any): VertMap;
+  };
+  FaceMap: {
+    fromArray(_0: any): FaceMap;
+  };
+  Face2RegionMap: {
+    fromArray(_0: any): Face2RegionMap;
+  };
+  VertColors: {
+    fromArray(_0: any): VertColors;
+  };
+  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;
+  };
+  VoxelsSave: {
+    toAnySupportedFormat(_0: VdbVolume, _1: EmbindString): void;
+  };
+}
+
+export type MainModule = WasmModule & EmbindModule;
+export default function MainModuleFactory (options?: unknown): Promise<MainModule>;