@faicad/faijs 0.29.5 → 0.31.1

package/dist/occt-kernel/generated/occtPlatform.generated.js

@@ -0,0 +1,875 @@
+// GENERATED FILE — DO NOT EDIT MANUALLY
+// Source: occt-wasm/dist/index.d.ts
+// occt-wasm version: 5.6.0
+// upstream d.ts hash: 056391ba46f1d6af
+// Generator: packages/core/scripts/gen-occt-platform.ts
+//
+// L2 平台直通面（OcctPlatformApi）：occt 专属、1:1 覆盖、生成式。
+// 每个薄封装统一 checkpoint() → 调用 → releaseSince(mark)，中间句柄不泄漏，
+// 返回的 ShapeHandle 交调用方 release。
+//
+// 生成器从 index.d.ts 直接产出，「全部能力可用」是结构性保证——
+// 上游加方法 → 生成器产出 → 类型系统可见，不存在「人忘了接」的环节。
+// 扫描器（scan-occt-wasm-surface.ts）只做兜底校验。
+export { BooleanOp, BooleanGlue, JoinType, SweepMode, SweepLaw, SweepContact, TransitionMode, OcctErrorCode } from 'occt-wasm';
+/**
+ * Create an OcctPlatformApi instance wrapping the given kernel.
+ *
+ * Each method call is bracketed by checkpoint()/releaseSince():
+ * intermediate temporary handles are auto-released, the returned
+ * ShapeHandle (if any) is preserved for the caller.
+ *
+ * @param kernel - the initialized OcctKernel instance
+ * @returns the platform API proxy
+ */
+export function createOcctPlatform(kernel) {
+    const api = {};
+    // OcctKernel#makeBox → ShapeHandle
+    api.makeBox = function (...args) {
+        return kernel.makeBox.apply(kernel, args);
+    };
+    // OcctKernel#makeBoxFromCorners → ShapeHandle
+    api.makeBoxFromCorners = function (...args) {
+        return kernel.makeBoxFromCorners.apply(kernel, args);
+    };
+    // OcctKernel#makeCylinder → ShapeHandle
+    api.makeCylinder = function (...args) {
+        return kernel.makeCylinder.apply(kernel, args);
+    };
+    // OcctKernel#makeSphere → ShapeHandle
+    api.makeSphere = function (...args) {
+        return kernel.makeSphere.apply(kernel, args);
+    };
+    // OcctKernel#makeCone → ShapeHandle
+    api.makeCone = function (...args) {
+        return kernel.makeCone.apply(kernel, args);
+    };
+    // OcctKernel#makeTorus → ShapeHandle
+    api.makeTorus = function (...args) {
+        return kernel.makeTorus.apply(kernel, args);
+    };
+    // OcctKernel#halfSpace → ShapeHandle
+    api.halfSpace = function (...args) {
+        return kernel.halfSpace.apply(kernel, args);
+    };
+    // OcctKernel#makeEllipsoid → ShapeHandle
+    api.makeEllipsoid = function (...args) {
+        return kernel.makeEllipsoid.apply(kernel, args);
+    };
+    // OcctKernel#makeRectangle → ShapeHandle
+    api.makeRectangle = function (...args) {
+        return kernel.makeRectangle.apply(kernel, args);
+    };
+    // OcctKernel#fuse → ShapeHandle
+    api.fuse = function (...args) {
+        return kernel.fuse.apply(kernel, args);
+    };
+    // OcctKernel#cut → ShapeHandle
+    api.cut = function (...args) {
+        return kernel.cut.apply(kernel, args);
+    };
+    // OcctKernel#common → ShapeHandle
+    api.common = function (...args) {
+        return kernel.common.apply(kernel, args);
+    };
+    // OcctKernel#intersect → ShapeHandle
+    api.intersect = function (...args) {
+        return kernel.intersect.apply(kernel, args);
+    };
+    // OcctKernel#section → ShapeHandle
+    api.section = function (...args) {
+        return kernel.section.apply(kernel, args);
+    };
+    // OcctKernel#sectionPlane → ShapeHandle
+    api.sectionPlane = function (...args) {
+        return kernel.sectionPlane.apply(kernel, args);
+    };
+    // OcctKernel#fuseAll → ShapeHandle
+    api.fuseAll = function (...args) {
+        return kernel.fuseAll.apply(kernel, args);
+    };
+    // OcctKernel#cutAll → ShapeHandle
+    api.cutAll = function (...args) {
+        return kernel.cutAll.apply(kernel, args);
+    };
+    // OcctKernel#split → ShapeHandle
+    api.split = function (...args) {
+        return kernel.split.apply(kernel, args);
+    };
+    // OcctKernel#intersectionCells → ShapeHandle
+    api.intersectionCells = function (...args) {
+        return kernel.intersectionCells.apply(kernel, args);
+    };
+    // OcctKernel#extrude → ShapeHandle
+    api.extrude = function (...args) {
+        return kernel.extrude.apply(kernel, args);
+    };
+    // OcctKernel#revolve → ShapeHandle
+    api.revolve = function (...args) {
+        return kernel.revolve.apply(kernel, args);
+    };
+    // OcctKernel#fillet → ShapeHandle
+    api.fillet = function (...args) {
+        return kernel.fillet.apply(kernel, args);
+    };
+    // OcctKernel#chamfer → ShapeHandle
+    api.chamfer = function (...args) {
+        return kernel.chamfer.apply(kernel, args);
+    };
+    // OcctKernel#chamferDistAngle → ShapeHandle
+    api.chamferDistAngle = function (...args) {
+        return kernel.chamferDistAngle.apply(kernel, args);
+    };
+    // OcctKernel#chamferAsymmetric → ShapeHandle
+    api.chamferAsymmetric = function (...args) {
+        return kernel.chamferAsymmetric.apply(kernel, args);
+    };
+    // OcctKernel#shell → ShapeHandle
+    api.shell = function (...args) {
+        return kernel.shell.apply(kernel, args);
+    };
+    // OcctKernel#offset → ShapeHandle
+    api.offset = function (...args) {
+        return kernel.offset.apply(kernel, args);
+    };
+    // OcctKernel#draft → ShapeHandle
+    api.draft = function (...args) {
+        return kernel.draft.apply(kernel, args);
+    };
+    // OcctKernel#pipe → ShapeHandle
+    api.pipe = function (...args) {
+        return kernel.pipe.apply(kernel, args);
+    };
+    // OcctKernel#simplePipe → ShapeHandle
+    api.simplePipe = function (...args) {
+        return kernel.simplePipe.apply(kernel, args);
+    };
+    // OcctKernel#loft → ShapeHandle
+    api.loft = function (...args) {
+        return kernel.loft.apply(kernel, args);
+    };
+    // OcctKernel#loftWithVertices → ShapeHandle
+    api.loftWithVertices = function (...args) {
+        return kernel.loftWithVertices.apply(kernel, args);
+    };
+    // OcctKernel#sweep → ShapeHandle
+    api.sweep = function (...args) {
+        return kernel.sweep.apply(kernel, args);
+    };
+    // OcctKernel#sweepPipeShell → ShapeHandle
+    api.sweepPipeShell = function (...args) {
+        return kernel.sweepPipeShell.apply(kernel, args);
+    };
+    // OcctKernel#sweepOriented → ShapeHandle
+    api.sweepOriented = function (...args) {
+        return kernel.sweepOriented.apply(kernel, args);
+    };
+    // OcctKernel#sweepAdvanced → ShapeHandle
+    api.sweepAdvanced = function (...args) {
+        return kernel.sweepAdvanced.apply(kernel, args);
+    };
+    // OcctKernel#sweepFull → ShapeHandle
+    api.sweepFull = function (...args) {
+        return kernel.sweepFull.apply(kernel, args);
+    };
+    // OcctKernel#draftPrism → ShapeHandle
+    api.draftPrism = function (...args) {
+        return kernel.draftPrism.apply(kernel, args);
+    };
+    // OcctKernel#makeVertex → ShapeHandle
+    api.makeVertex = function (...args) {
+        return kernel.makeVertex.apply(kernel, args);
+    };
+    // OcctKernel#makeEdge → ShapeHandle
+    api.makeEdge = function (...args) {
+        return kernel.makeEdge.apply(kernel, args);
+    };
+    // OcctKernel#makeLineEdge → ShapeHandle
+    api.makeLineEdge = function (...args) {
+        return kernel.makeLineEdge.apply(kernel, args);
+    };
+    // OcctKernel#makeCircleEdge → ShapeHandle
+    api.makeCircleEdge = function (...args) {
+        return kernel.makeCircleEdge.apply(kernel, args);
+    };
+    // OcctKernel#makeCircleArc → ShapeHandle
+    api.makeCircleArc = function (...args) {
+        return kernel.makeCircleArc.apply(kernel, args);
+    };
+    // OcctKernel#makeArcEdge → ShapeHandle
+    api.makeArcEdge = function (...args) {
+        return kernel.makeArcEdge.apply(kernel, args);
+    };
+    // OcctKernel#makeEllipseEdge → ShapeHandle
+    api.makeEllipseEdge = function (...args) {
+        return kernel.makeEllipseEdge.apply(kernel, args);
+    };
+    // OcctKernel#makeEllipseArc → ShapeHandle
+    api.makeEllipseArc = function (...args) {
+        return kernel.makeEllipseArc.apply(kernel, args);
+    };
+    // OcctKernel#makeBezierEdge → ShapeHandle
+    api.makeBezierEdge = function (...args) {
+        return kernel.makeBezierEdge.apply(kernel, args);
+    };
+    // OcctKernel#makeBSplineEdge → ShapeHandle
+    api.makeBSplineEdge = function (...args) {
+        return kernel.makeBSplineEdge.apply(kernel, args);
+    };
+    // OcctKernel#makeTangentArc → ShapeHandle
+    api.makeTangentArc = function (...args) {
+        return kernel.makeTangentArc.apply(kernel, args);
+    };
+    // OcctKernel#makeHelixWire → ShapeHandle
+    api.makeHelixWire = function (...args) {
+        return kernel.makeHelixWire.apply(kernel, args);
+    };
+    // OcctKernel#makeHelixWireHanded → ShapeHandle
+    api.makeHelixWireHanded = function (...args) {
+        return kernel.makeHelixWireHanded.apply(kernel, args);
+    };
+    // OcctKernel#makeWire → ShapeHandle
+    api.makeWire = function (...args) {
+        return kernel.makeWire.apply(kernel, args);
+    };
+    // OcctKernel#makeFace → ShapeHandle
+    api.makeFace = function (...args) {
+        return kernel.makeFace.apply(kernel, args);
+    };
+    // OcctKernel#makeNonPlanarFace → ShapeHandle
+    api.makeNonPlanarFace = function (...args) {
+        return kernel.makeNonPlanarFace.apply(kernel, args);
+    };
+    // OcctKernel#addHolesInFace → ShapeHandle
+    api.addHolesInFace = function (...args) {
+        return kernel.addHolesInFace.apply(kernel, args);
+    };
+    // OcctKernel#removeHolesFromFace → ShapeHandle
+    api.removeHolesFromFace = function (...args) {
+        return kernel.removeHolesFromFace.apply(kernel, args);
+    };
+    // OcctKernel#makeSolid → ShapeHandle
+    api.makeSolid = function (...args) {
+        return kernel.makeSolid.apply(kernel, args);
+    };
+    // OcctKernel#sew → ShapeHandle
+    api.sew = function (...args) {
+        return kernel.sew.apply(kernel, args);
+    };
+    // OcctKernel#sewAndSolidify → ShapeHandle
+    api.sewAndSolidify = function (...args) {
+        return kernel.sewAndSolidify.apply(kernel, args);
+    };
+    // OcctKernel#buildSolidFromFaces → ShapeHandle
+    api.buildSolidFromFaces = function (...args) {
+        return kernel.buildSolidFromFaces.apply(kernel, args);
+    };
+    // OcctKernel#makeCompound → ShapeHandle
+    api.makeCompound = function (...args) {
+        return kernel.makeCompound.apply(kernel, args);
+    };
+    // OcctKernel#buildTriFace → ShapeHandle
+    api.buildTriFace = function (...args) {
+        return kernel.buildTriFace.apply(kernel, args);
+    };
+    // OcctKernel#makeFaceOnSurface → ShapeHandle
+    api.makeFaceOnSurface = function (...args) {
+        return kernel.makeFaceOnSurface.apply(kernel, args);
+    };
+    // OcctKernel#makeNullShape → ShapeHandle
+    api.makeNullShape = function (...args) {
+        return kernel.makeNullShape.apply(kernel, args);
+    };
+    // OcctKernel#translate → ShapeHandle
+    api.translate = function (...args) {
+        return kernel.translate.apply(kernel, args);
+    };
+    // OcctKernel#alignX → ShapeHandle
+    api.alignX = function (...args) {
+        return kernel.alignX.apply(kernel, args);
+    };
+    // OcctKernel#alignY → ShapeHandle
+    api.alignY = function (...args) {
+        return kernel.alignY.apply(kernel, args);
+    };
+    // OcctKernel#alignZ → ShapeHandle
+    api.alignZ = function (...args) {
+        return kernel.alignZ.apply(kernel, args);
+    };
+    // OcctKernel#rotate → ShapeHandle
+    api.rotate = function (...args) {
+        return kernel.rotate.apply(kernel, args);
+    };
+    // OcctKernel#scale → ShapeHandle
+    api.scale = function (...args) {
+        return kernel.scale.apply(kernel, args);
+    };
+    // OcctKernel#mirror → ShapeHandle
+    api.mirror = function (...args) {
+        return kernel.mirror.apply(kernel, args);
+    };
+    // OcctKernel#copy → ShapeHandle
+    api.copy = function (...args) {
+        return kernel.copy.apply(kernel, args);
+    };
+    // OcctKernel#transform → ShapeHandle
+    api.transform = function (...args) {
+        return kernel.transform.apply(kernel, args);
+    };
+    // OcctKernel#located → ShapeHandle
+    api.located = function (...args) {
+        return kernel.located.apply(kernel, args);
+    };
+    // OcctKernel#generalTransform → ShapeHandle
+    api.generalTransform = function (...args) {
+        return kernel.generalTransform.apply(kernel, args);
+    };
+    // OcctKernel#linearPattern → ShapeHandle
+    api.linearPattern = function (...args) {
+        return kernel.linearPattern.apply(kernel, args);
+    };
+    // OcctKernel#circularPattern → ShapeHandle
+    api.circularPattern = function (...args) {
+        return kernel.circularPattern.apply(kernel, args);
+    };
+    // OcctKernel#composeTransform → number[]
+    api.composeTransform = function (...args) {
+        return kernel.composeTransform.apply(kernel, args);
+    };
+    // OcctKernel#translateBatch → ShapeHandle[]
+    api.translateBatch = function (...args) {
+        return kernel.translateBatch.apply(kernel, args);
+    };
+    // OcctKernel#booleanOp → EvolutionData
+    api.booleanOp = function (...args) {
+        return kernel.booleanOp.apply(kernel, args);
+    };
+    // OcctKernel#booleanPipeline → ShapeHandle
+    api.booleanPipeline = function (...args) {
+        return kernel.booleanPipeline.apply(kernel, args);
+    };
+    // OcctKernel#queryBatch → ShapeQueryResult[]
+    api.queryBatch = function (...args) {
+        return kernel.queryBatch.apply(kernel, args);
+    };
+    // OcctKernel#filletBatch → ShapeHandle[]
+    api.filletBatch = function (...args) {
+        return kernel.filletBatch.apply(kernel, args);
+    };
+    // OcctKernel#transformBatch → ShapeHandle[]
+    api.transformBatch = function (...args) {
+        return kernel.transformBatch.apply(kernel, args);
+    };
+    // OcctKernel#rotateBatch → ShapeHandle[]
+    api.rotateBatch = function (...args) {
+        return kernel.rotateBatch.apply(kernel, args);
+    };
+    // OcctKernel#scaleBatch → ShapeHandle[]
+    api.scaleBatch = function (...args) {
+        return kernel.scaleBatch.apply(kernel, args);
+    };
+    // OcctKernel#mirrorBatch → ShapeHandle[]
+    api.mirrorBatch = function (...args) {
+        return kernel.mirrorBatch.apply(kernel, args);
+    };
+    // OcctKernel#getShapeType → ShapeType
+    api.getShapeType = function (...args) {
+        return kernel.getShapeType.apply(kernel, args);
+    };
+    // OcctKernel#isCompound → boolean
+    api.isCompound = function (...args) {
+        return kernel.isCompound.apply(kernel, args);
+    };
+    // OcctKernel#isCompSolid → boolean
+    api.isCompSolid = function (...args) {
+        return kernel.isCompSolid.apply(kernel, args);
+    };
+    // OcctKernel#isSolid → boolean
+    api.isSolid = function (...args) {
+        return kernel.isSolid.apply(kernel, args);
+    };
+    // OcctKernel#isShell → boolean
+    api.isShell = function (...args) {
+        return kernel.isShell.apply(kernel, args);
+    };
+    // OcctKernel#isFace → boolean
+    api.isFace = function (...args) {
+        return kernel.isFace.apply(kernel, args);
+    };
+    // OcctKernel#isWire → boolean
+    api.isWire = function (...args) {
+        return kernel.isWire.apply(kernel, args);
+    };
+    // OcctKernel#isEdge → boolean
+    api.isEdge = function (...args) {
+        return kernel.isEdge.apply(kernel, args);
+    };
+    // OcctKernel#isVertex → boolean
+    api.isVertex = function (...args) {
+        return kernel.isVertex.apply(kernel, args);
+    };
+    // OcctKernel#getSubShapes → ShapeHandle[]
+    api.getSubShapes = function (...args) {
+        return kernel.getSubShapes.apply(kernel, args);
+    };
+    // OcctKernel#subShapeCount → number
+    api.subShapeCount = function (...args) {
+        return kernel.subShapeCount.apply(kernel, args);
+    };
+    // OcctKernel#subShapeHashes → number[]
+    api.subShapeHashes = function (...args) {
+        return kernel.subShapeHashes.apply(kernel, args);
+    };
+    // OcctKernel#downcast → ShapeHandle
+    api.downcast = function (...args) {
+        return kernel.downcast.apply(kernel, args);
+    };
+    // OcctKernel#distanceBetween → number
+    api.distanceBetween = function (...args) {
+        return kernel.distanceBetween.apply(kernel, args);
+    };
+    // OcctKernel#isSame → boolean
+    api.isSame = function (...args) {
+        return kernel.isSame.apply(kernel, args);
+    };
+    // OcctKernel#isEqual → boolean
+    api.isEqual = function (...args) {
+        return kernel.isEqual.apply(kernel, args);
+    };
+    // OcctKernel#isNull → boolean
+    api.isNull = function (...args) {
+        return kernel.isNull.apply(kernel, args);
+    };
+    // OcctKernel#hashCode → number
+    api.hashCode = function (...args) {
+        return kernel.hashCode.apply(kernel, args);
+    };
+    // OcctKernel#shapeOrientation → ShapeOrientation
+    api.shapeOrientation = function (...args) {
+        return kernel.shapeOrientation.apply(kernel, args);
+    };
+    // OcctKernel#sharedEdges → ShapeHandle[]
+    api.sharedEdges = function (...args) {
+        return kernel.sharedEdges.apply(kernel, args);
+    };
+    // OcctKernel#adjacentFaces → ShapeHandle[]
+    api.adjacentFaces = function (...args) {
+        return kernel.adjacentFaces.apply(kernel, args);
+    };
+    // OcctKernel#iterShapes → ShapeHandle[]
+    api.iterShapes = function (...args) {
+        return kernel.iterShapes.apply(kernel, args);
+    };
+    // OcctKernel#edgeToFaceMap → number[]
+    api.edgeToFaceMap = function (...args) {
+        return kernel.edgeToFaceMap.apply(kernel, args);
+    };
+    // OcctKernel#tessellate → Mesh
+    api.tessellate = function (...args) {
+        return kernel.tessellate.apply(kernel, args);
+    };
+    // OcctKernel#wireframe → EdgeData
+    api.wireframe = function (...args) {
+        return kernel.wireframe.apply(kernel, args);
+    };
+    // OcctKernel#hasTriangulation → boolean
+    api.hasTriangulation = function (...args) {
+        return kernel.hasTriangulation.apply(kernel, args);
+    };
+    // OcctKernel#meshShape → Mesh
+    api.meshShape = function (...args) {
+        return kernel.meshShape.apply(kernel, args);
+    };
+    // OcctKernel#meshBatch → MeshBatchData
+    api.meshBatch = function (...args) {
+        return kernel.meshBatch.apply(kernel, args);
+    };
+    // OcctKernel#importStep → ShapeHandle
+    api.importStep = function (...args) {
+        return kernel.importStep.apply(kernel, args);
+    };
+    // OcctKernel#exportStep → string
+    api.exportStep = function (...args) {
+        return kernel.exportStep.apply(kernel, args);
+    };
+    // OcctKernel#importStl → ShapeHandle
+    api.importStl = function (...args) {
+        return kernel.importStl.apply(kernel, args);
+    };
+    // OcctKernel#exportStl → string | Uint8Array
+    api.exportStl = function (...args) {
+        return kernel.exportStl.apply(kernel, args);
+    };
+    // OcctKernel#toBREP → string
+    api.toBREP = function (...args) {
+        return kernel.toBREP.apply(kernel, args);
+    };
+    // OcctKernel#fromBREP → ShapeHandle
+    api.fromBREP = function (...args) {
+        return kernel.fromBREP.apply(kernel, args);
+    };
+    // OcctKernel#toBREPBinary → Uint8Array
+    api.toBREPBinary = function (...args) {
+        return kernel.toBREPBinary.apply(kernel, args);
+    };
+    // OcctKernel#fromBREPBinary → ShapeHandle
+    api.fromBREPBinary = function (...args) {
+        return kernel.fromBREPBinary.apply(kernel, args);
+    };
+    // OcctKernel#cacheStep → string
+    api.cacheStep = function (...args) {
+        return kernel.cacheStep.apply(kernel, args);
+    };
+    // OcctKernel#loadCached → ShapeHandle
+    api.loadCached = function (...args) {
+        return kernel.loadCached.apply(kernel, args);
+    };
+    // OcctKernel#getBoundingBox → BoundingBox
+    api.getBoundingBox = function (...args) {
+        return kernel.getBoundingBox.apply(kernel, args);
+    };
+    // OcctKernel#getVolume → number
+    api.getVolume = function (...args) {
+        return kernel.getVolume.apply(kernel, args);
+    };
+    // OcctKernel#getSurfaceArea → number
+    api.getSurfaceArea = function (...args) {
+        return kernel.getSurfaceArea.apply(kernel, args);
+    };
+    // OcctKernel#getLength → number
+    api.getLength = function (...args) {
+        return kernel.getLength.apply(kernel, args);
+    };
+    // OcctKernel#getCenterOfMass → Vec3
+    api.getCenterOfMass = function (...args) {
+        return kernel.getCenterOfMass.apply(kernel, args);
+    };
+    // OcctKernel#getInertia → number[]
+    api.getInertia = function (...args) {
+        return kernel.getInertia.apply(kernel, args);
+    };
+    // OcctKernel#containsPoint → boolean
+    api.containsPoint = function (...args) {
+        return kernel.containsPoint.apply(kernel, args);
+    };
+    // OcctKernel#getSurfaceCenterOfMass → Vec3
+    api.getSurfaceCenterOfMass = function (...args) {
+        return kernel.getSurfaceCenterOfMass.apply(kernel, args);
+    };
+    // OcctKernel#getLinearCenterOfMass → Vec3
+    api.getLinearCenterOfMass = function (...args) {
+        return kernel.getLinearCenterOfMass.apply(kernel, args);
+    };
+    // OcctKernel#surfaceCurvature → CurvatureData
+    api.surfaceCurvature = function (...args) {
+        return kernel.surfaceCurvature.apply(kernel, args);
+    };
+    // OcctKernel#vertexPosition → Vec3
+    api.vertexPosition = function (...args) {
+        return kernel.vertexPosition.apply(kernel, args);
+    };
+    // OcctKernel#surfaceType → SurfaceKind
+    api.surfaceType = function (...args) {
+        return kernel.surfaceType.apply(kernel, args);
+    };
+    // OcctKernel#surfaceNormal → Vec3
+    api.surfaceNormal = function (...args) {
+        return kernel.surfaceNormal.apply(kernel, args);
+    };
+    // OcctKernel#pointOnSurface → Vec3
+    api.pointOnSurface = function (...args) {
+        return kernel.pointOnSurface.apply(kernel, args);
+    };
+    // OcctKernel#outerWire → ShapeHandle
+    api.outerWire = function (...args) {
+        return kernel.outerWire.apply(kernel, args);
+    };
+    // OcctKernel#reverseSurfaceU → ShapeHandle
+    api.reverseSurfaceU = function (...args) {
+        return kernel.reverseSurfaceU.apply(kernel, args);
+    };
+    // OcctKernel#uvBounds → UVBounds
+    api.uvBounds = function (...args) {
+        return kernel.uvBounds.apply(kernel, args);
+    };
+    // OcctKernel#uvFromPoint → {
+    //         u: number;
+    //         v: number;
+    //     }
+    api.uvFromPoint = function (...args) {
+        return kernel.uvFromPoint.apply(kernel, args);
+    };
+    // OcctKernel#getFaceCylinderData → {
+    //         radius: number;
+    //         isDirect: boolean;
+    //     } | null
+    api.getFaceCylinderData = function (...args) {
+        return kernel.getFaceCylinderData.apply(kernel, args);
+    };
+    // OcctKernel#projectPointOnFace → Vec3
+    api.projectPointOnFace = function (...args) {
+        return kernel.projectPointOnFace.apply(kernel, args);
+    };
+    // OcctKernel#classifyPointOnFace → PointClassification
+    api.classifyPointOnFace = function (...args) {
+        return kernel.classifyPointOnFace.apply(kernel, args);
+    };
+    // OcctKernel#bsplineSurface → ShapeHandle
+    api.bsplineSurface = function (...args) {
+        return kernel.bsplineSurface.apply(kernel, args);
+    };
+    // OcctKernel#curveType → CurveKind
+    api.curveType = function (...args) {
+        return kernel.curveType.apply(kernel, args);
+    };
+    // OcctKernel#curvePointAtParam → Vec3
+    api.curvePointAtParam = function (...args) {
+        return kernel.curvePointAtParam.apply(kernel, args);
+    };
+    // OcctKernel#curveTangent → Vec3
+    api.curveTangent = function (...args) {
+        return kernel.curveTangent.apply(kernel, args);
+    };
+    // OcctKernel#curveParameters → {
+    //         first: number;
+    //         last: number;
+    //     }
+    api.curveParameters = function (...args) {
+        return kernel.curveParameters.apply(kernel, args);
+    };
+    // OcctKernel#curveIsClosed → boolean
+    api.curveIsClosed = function (...args) {
+        return kernel.curveIsClosed.apply(kernel, args);
+    };
+    // OcctKernel#curveIsPeriodic → boolean
+    api.curveIsPeriodic = function (...args) {
+        return kernel.curveIsPeriodic.apply(kernel, args);
+    };
+    // OcctKernel#curveLength → number
+    api.curveLength = function (...args) {
+        return kernel.curveLength.apply(kernel, args);
+    };
+    // OcctKernel#interpolatePoints → ShapeHandle
+    api.interpolatePoints = function (...args) {
+        return kernel.interpolatePoints.apply(kernel, args);
+    };
+    // OcctKernel#interpolatePointsWithTangents → ShapeHandle
+    api.interpolatePointsWithTangents = function (...args) {
+        return kernel.interpolatePointsWithTangents.apply(kernel, args);
+    };
+    // OcctKernel#projectPointOnEdge → {
+    //         point: Vec3;
+    //         tangent: Vec3;
+    //         parameter: number;
+    //     }
+    api.projectPointOnEdge = function (...args) {
+        return kernel.projectPointOnEdge.apply(kernel, args);
+    };
+    // OcctKernel#approximatePoints → ShapeHandle
+    api.approximatePoints = function (...args) {
+        return kernel.approximatePoints.apply(kernel, args);
+    };
+    // OcctKernel#getNurbsCurveData → NurbsCurveData
+    api.getNurbsCurveData = function (...args) {
+        return kernel.getNurbsCurveData.apply(kernel, args);
+    };
+    // OcctKernel#curveDegreeElevate → ShapeHandle
+    api.curveDegreeElevate = function (...args) {
+        return kernel.curveDegreeElevate.apply(kernel, args);
+    };
+    // OcctKernel#curveKnotInsert → ShapeHandle
+    api.curveKnotInsert = function (...args) {
+        return kernel.curveKnotInsert.apply(kernel, args);
+    };
+    // OcctKernel#curveKnotRemove → ShapeHandle
+    api.curveKnotRemove = function (...args) {
+        return kernel.curveKnotRemove.apply(kernel, args);
+    };
+    // OcctKernel#curveSplit → [ShapeHandle, ShapeHandle]
+    api.curveSplit = function (...args) {
+        return kernel.curveSplit.apply(kernel, args);
+    };
+    // OcctKernel#liftCurve2dToPlane → ShapeHandle
+    api.liftCurve2dToPlane = function (...args) {
+        return kernel.liftCurve2dToPlane.apply(kernel, args);
+    };
+    // OcctKernel#projectEdges → ProjectionData
+    api.projectEdges = function (...args) {
+        return kernel.projectEdges.apply(kernel, args);
+    };
+    // OcctKernel#toSVG → string
+    api.toSVG = function (...args) {
+        return kernel.toSVG.apply(kernel, args);
+    };
+    // OcctKernel#toMultiviewSVG → string
+    api.toMultiviewSVG = function (...args) {
+        return kernel.toMultiviewSVG.apply(kernel, args);
+    };
+    // OcctKernel#toPNG → Promise<Uint8Array>
+    api.toPNG = function (...args) {
+        return kernel.toPNG.apply(kernel, args);
+    };
+    // OcctKernel#toMultiviewPNG → Promise<Uint8Array>
+    api.toMultiviewPNG = function (...args) {
+        return kernel.toMultiviewPNG.apply(kernel, args);
+    };
+    // OcctKernel#thicken → ShapeHandle
+    api.thicken = function (...args) {
+        return kernel.thicken.apply(kernel, args);
+    };
+    // OcctKernel#defeature → ShapeHandle
+    api.defeature = function (...args) {
+        return kernel.defeature.apply(kernel, args);
+    };
+    // OcctKernel#reverseShape → ShapeHandle
+    api.reverseShape = function (...args) {
+        return kernel.reverseShape.apply(kernel, args);
+    };
+    // OcctKernel#simplify → ShapeHandle
+    api.simplify = function (...args) {
+        return kernel.simplify.apply(kernel, args);
+    };
+    // OcctKernel#filletVariable → ShapeHandle
+    api.filletVariable = function (...args) {
+        return kernel.filletVariable.apply(kernel, args);
+    };
+    // OcctKernel#offsetWire2D → ShapeHandle
+    api.offsetWire2D = function (...args) {
+        return kernel.offsetWire2D.apply(kernel, args);
+    };
+    // OcctKernel#translateWithHistory → EvolutionData
+    api.translateWithHistory = function (...args) {
+        return kernel.translateWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#fuseWithHistory → EvolutionData
+    api.fuseWithHistory = function (...args) {
+        return kernel.fuseWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#cutWithHistory → EvolutionData
+    api.cutWithHistory = function (...args) {
+        return kernel.cutWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#filletWithHistory → EvolutionData
+    api.filletWithHistory = function (...args) {
+        return kernel.filletWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#rotateWithHistory → EvolutionData
+    api.rotateWithHistory = function (...args) {
+        return kernel.rotateWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#mirrorWithHistory → EvolutionData
+    api.mirrorWithHistory = function (...args) {
+        return kernel.mirrorWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#scaleWithHistory → EvolutionData
+    api.scaleWithHistory = function (...args) {
+        return kernel.scaleWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#intersectWithHistory → EvolutionData
+    api.intersectWithHistory = function (...args) {
+        return kernel.intersectWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#chamferWithHistory → EvolutionData
+    api.chamferWithHistory = function (...args) {
+        return kernel.chamferWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#shellWithHistory → EvolutionData
+    api.shellWithHistory = function (...args) {
+        return kernel.shellWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#offsetWithHistory → EvolutionData
+    api.offsetWithHistory = function (...args) {
+        return kernel.offsetWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#thickenWithHistory → EvolutionData
+    api.thickenWithHistory = function (...args) {
+        return kernel.thickenWithHistory.apply(kernel, args);
+    };
+    // OcctKernel#fixShape → ShapeHandle
+    api.fixShape = function (...args) {
+        return kernel.fixShape.apply(kernel, args);
+    };
+    // OcctKernel#unifySameDomain → ShapeHandle
+    api.unifySameDomain = function (...args) {
+        return kernel.unifySameDomain.apply(kernel, args);
+    };
+    // OcctKernel#isValid → boolean
+    api.isValid = function (...args) {
+        return kernel.isValid.apply(kernel, args);
+    };
+    // OcctKernel#healSolid → ShapeHandle
+    api.healSolid = function (...args) {
+        return kernel.healSolid.apply(kernel, args);
+    };
+    // OcctKernel#healFace → ShapeHandle
+    api.healFace = function (...args) {
+        return kernel.healFace.apply(kernel, args);
+    };
+    // OcctKernel#healWire → ShapeHandle
+    api.healWire = function (...args) {
+        return kernel.healWire.apply(kernel, args);
+    };
+    // OcctKernel#fixFaceOrientations → ShapeHandle
+    api.fixFaceOrientations = function (...args) {
+        return kernel.fixFaceOrientations.apply(kernel, args);
+    };
+    // OcctKernel#removeDegenerateEdges → ShapeHandle
+    api.removeDegenerateEdges = function (...args) {
+        return kernel.removeDegenerateEdges.apply(kernel, args);
+    };
+    // OcctKernel#buildCurves3d → void
+    api.buildCurves3d = function (...args) {
+        const mark = kernel.checkpoint();
+        try {
+            ;
+            kernel.buildCurves3d.apply(kernel, args);
+        }
+        finally {
+            kernel.releaseSince(mark);
+        }
+    };
+    // OcctKernel#fixWireOnFace → ShapeHandle
+    api.fixWireOnFace = function (...args) {
+        return kernel.fixWireOnFace.apply(kernel, args);
+    };
+    // OcctKernel#createXCAFDocument → XCAFDocument
+    api.createXCAFDocument = function (...args) {
+        return kernel.createXCAFDocument.apply(kernel, args);
+    };
+    // OcctKernel#importXCAFFromSTEP → XCAFDocument
+    api.importXCAFFromSTEP = function (...args) {
+        return kernel.importXCAFFromSTEP.apply(kernel, args);
+    };
+    // OcctKernel#release → void
+    api.release = function (...args) {
+        const mark = kernel.checkpoint();
+        try {
+            ;
+            kernel.release.apply(kernel, args);
+        }
+        finally {
+            kernel.releaseSince(mark);
+        }
+    };
+    // OcctKernel#checkpoint → number
+    api.checkpoint = function (...args) {
+        return kernel.checkpoint.apply(kernel, args);
+    };
+    // OcctKernel#releaseSince → void
+    api.releaseSince = function (...args) {
+        const mark = kernel.checkpoint();
+        try {
+            ;
+            kernel.releaseSince.apply(kernel, args);
+        }
+        finally {
+            kernel.releaseSince(mark);
+        }
+    };
+    // OcctKernel#describe → string
+    api.describe = function (...args) {
+        return kernel.describe.apply(kernel, args);
+    };
+    return api;
+}
+//# sourceMappingURL=occtPlatform.generated.js.map