@buerli.io/headless 0.5.0-beta.1 → 0.5.0-beta.3

package/build/{history.js → esm/history.js}

@@ -13,26 +13,14 @@ import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUt
 import { waitForSelect } from './utils/selection';
 const featureAPI = ccAPI.feature;
 const sketcherAPI = ccAPI.sketcher;
-const base = ccUtils.base;
+const baseModelerAPI = ccAPI.baseModeler;
+const assemblyBuilderAPI = ccAPI.assemblyBuilder;
+const baseUtils = ccUtils.base;
+const asmUtils = ccUtils.assembly;
 let BufferGeometryUtils = BufferGeometryUtils_;
 if (BufferGeometryUtils.BufferGeometryUtils) {
     BufferGeometryUtils = BufferGeometryUtils.BufferGeometryUtils;
 }
-/**
- * Returns the data type of the given value
- * @param value value to get the data type from
- * @returns datatype of value
- */
-const getDataType = (value) => {
-    switch (typeof value) {
-        case 'number':
-            return DataType.REAL;
-        case 'object':
-            return DataType.POINT;
-        case 'string':
-            return DataType.STRING;
-    }
-};
 /**
  * Returns the cclass of the given dimension type
  * @param type type of the dimension as string
@@ -56,7 +44,7 @@ const getDimensionType = (type) => {
  */
 const getGlobalTransformation = (drawingId, ownerId, localTransformation) => {
     const lT = localTransformation;
-    const coordSysOwner = ccUtils.assembly.getCoordSysFromNode(drawingId, ownerId);
+    const coordSysOwner = asmUtils.getCoordSysFromNode(drawingId, ownerId);
     if (coordSysOwner) {
         const origin = [lT[0].x, lT[0].y, lT[0].z];
         const xAxis = [lT[1].x, lT[1].y, lT[1].z];
@@ -124,83 +112,80 @@ const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray)
     }
 };
 /**
- * We traverse recursively over structure tree, starting with object and create three objects and meshes
- * for the scene. Each part or assembly will be turned into groups and subgroups. Solids from parts will be turned
- * into merged meshes, which are children of the group. Faces of a solid with different color
+ * We traverse recursively over structure tree, starting with object and create THREE objects
+ * for the scene. Each part or assembly will be turned into groups and subgroups. Solids which are children of the
+ * parts will be turned into groups as well. Children of solids will be merged to meshes. Faces of a solid with different color
  * or transparency will get its own mesh.
  * @param object root object where we start building the three scene
  * @param drawingId id of the drawing
  * @param root the root of the scene
- * @param options e.g. meshPerFace controls if each face gets a own mesh or if they will be combined/merged
+ * @param result object containing all the current collected nodes, solids, meshes
+ * @param options e.g. meshPerGeometry controls if each geometry element gets a own mesh or if they will be combined/merged
  */
-const createRecursiveScene = async (object, drawingId, root, options) => {
+const createRecursiveScene = async (object, drawingId, root, result, options) => {
     let cDrawing = getDrawing(drawingId);
     const tree = cDrawing.structure.tree;
     if (object.link || object.solids) {
         // Part
-        const solids = object.link ? tree[object.link].solids : object.solids;
-        if (solids != undefined) {
-            let meshes = [];
-            const cachedSolids = [];
-            for (const solid of solids) {
-                let cachedSolid = cDrawing.geometry.cache[solid];
-                if (!cachedSolid) {
+        const entities = object.link ? tree[object.link].solids : object.solids;
+        if (entities != undefined) {
+            const part = new Group();
+            part.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
+            part.matrixAutoUpdate = false;
+            part.userData = { id: object.id }; // product reference id
+            part.name = object.name; // product reference name
+            for (const entity of entities) {
+                let cachedEntity = cDrawing.geometry.cache[entity];
+                if (!cachedEntity) {
                     // else get visualisation from classcad
-                    await ccAPI.baseModeler.requestVisualisationOfEntities(drawingId, [solid]);
+                    await ccAPI.baseModeler.requestVisualisationOfEntities(drawingId, [entity]);
                     cDrawing = getDrawing(drawingId); // get current drawing state after request
-                    cachedSolid = cDrawing.geometry.cache[solid];
+                    cachedEntity = cDrawing.geometry.cache[entity];
                 }
-                if (cachedSolid) {
-                    if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
-                        meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
-                    }
-                    else {
-                        cachedSolids.push(cachedSolid);
-                    }
-                }
-            }
-            // If meshPerFace = true, we create for each face a separat mesh
-            if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
-                if (meshes.length > 0) {
-                    const part = new Group();
-                    part.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
-                    part.matrixAutoUpdate = false;
-                    part.userData = { id: object.id }; // product reference id
-                    part.name = object.name; // product reference name
-                    for (const mesh of meshes) {
-                        part.add(new Mesh(mesh.geometry, new MeshStandardMaterial({ color: mesh.color, transparent: mesh.opacity < 1, opacity: mesh.opacity })));
-                    }
-                    root.add(part);
-                }
-            }
-            else {
-                if (cachedSolids.length > 0) {
-                    const part = new Group();
-                    part.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
-                    part.matrixAutoUpdate = false;
-                    part.userData = { id: object.id }; // product reference id
-                    part.name = object.name; // product reference name
-                    // A cached solid can have different colored faces, e.g. if a brep has been decorated.
-                    // In that case, we group the meshes with the same color/tranparency
-                    for (const cs of cachedSolids) {
-                        const colorMeshesMap = getDifferentColoredMeshesFromSolid(cs);
-                        Object.keys(colorMeshesMap).forEach(key => {
-                            const coloredMeshes = colorMeshesMap[key];
-                            const mesh = new Mesh();
-                            mesh.userData = { id: cs.container.ownerId }; // solid id
-                            mesh.name = tree[cs.container.ownerId].name; // solid name
-                            mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(coloredMeshes.map(m => m.geometry));
-                            mesh.material = new MeshStandardMaterial({
-                                color: coloredMeshes[0].color,
-                                transparent: coloredMeshes[0].opacity < 1,
-                                opacity: coloredMeshes[0].opacity,
+                if (cachedEntity && cachedEntity.meshes.length > 0) {
+                    const solidObject = cDrawing.structure.tree[cachedEntity.container.ownerId];
+                    if (solidObject) {
+                        const _solid = new Group();
+                        _solid.name = solidObject.name;
+                        _solid.userData = { id: solidObject.id }; // add solid id to the userData
+                        if (options === null || options === void 0 ? void 0 : options.meshPerGeometry) {
+                            // Create a mesh for each geometry element
+                            cachedEntity.meshes.forEach(m => {
+                                const mesh = new Mesh();
+                                mesh.userData = { id: m.graphicId }; // add graphic id to the userData
+                                mesh.geometry = m.geometry;
+                                mesh.material = new MeshStandardMaterial({
+                                    color: m.color,
+                                    transparent: m.opacity < 1,
+                                    opacity: m.opacity,
+                                });
+                                _solid.add(mesh);
+                                result.meshes.push(mesh);
                             });
-                            part.add(mesh);
-                        });
+                        }
+                        else {
+                            // Merge all geometries into one mesh, sort them by color
+                            const colorMeshesMap = getDifferentColoredMeshesFromEntity(cachedEntity);
+                            Object.keys(colorMeshesMap).forEach(key => {
+                                const coloredMeshes = colorMeshesMap[key];
+                                const mesh = new Mesh();
+                                mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(coloredMeshes.map(m => m.geometry));
+                                mesh.material = new MeshStandardMaterial({
+                                    color: coloredMeshes[0].color,
+                                    transparent: coloredMeshes[0].opacity < 1,
+                                    opacity: coloredMeshes[0].opacity,
+                                });
+                                _solid.add(mesh); // Add mesh to solid of the scene
+                                result.meshes.push(mesh); // Collect mesh to return result later
+                            });
+                        }
+                        part.add(_solid);
+                        result.solids.push(_solid);
                     }
-                    root.add(part);
                 }
             }
+            root.add(part);
+            result.nodes.push(part);
         }
     }
     else if (object.children) {
@@ -210,22 +195,23 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
         assembly.matrixAutoUpdate = false;
         assembly.userData = { id: object.id }; // assembly root or product reference id
         assembly.name = object.name; // assembly root or product reference name
+        result.nodes.push(assembly);
         root.add(assembly);
         for (const child of object.children) {
             if (tree[child].class === CCClasses.CCProductReference || tree[child].class === CCClasses.CCProductReferenceET) {
-                await createRecursiveScene(tree[child], drawingId, assembly, options);
+                await createRecursiveScene(tree[child], drawingId, assembly, result, options);
             }
         }
     }
 };
 /**
  * Get all meshes in a map, sorted by their color / transparency
- * @param solid solid to look for the meshes
+ * @param entity entity to look for the meshes
  * @returns map (key = color/transparency as string, value = meshes array)
  */
-const getDifferentColoredMeshesFromSolid = (solid) => {
+const getDifferentColoredMeshesFromEntity = (entity) => {
     const colorMeshesMap = {};
-    solid.meshes.forEach(mesh => {
+    entity.meshes.forEach(mesh => {
         const key = mesh.color.getHexString() + mesh.opacity.toString();
         if (colorMeshesMap[key]) {
             colorMeshesMap[key].push(mesh);
@@ -278,12 +264,6 @@ export default class CAD {
                 throw new Error('Drawing could not be created');
             this.drawingId = drawingId;
             const publicApi = {
-                addNode: (productId, ownerId, transformation, name) => {
-                    return this.resolve(async ([rProductId, rOwnerId]) => {
-                        const globalTransformation = getGlobalTransformation(drawingId, rOwnerId, transformation) || transformation;
-                        return ccAPI.assemblyBuilder.addNode(drawingId, rProductId, rOwnerId, globalTransformation, name);
-                    }, productId, ownerId);
-                },
                 addNodes: async (...nodes) => {
                     var e_1, _a;
                     const nodesToAdd = [];
@@ -309,29 +289,6 @@ export default class CAD {
                     }
                     return ccAPI.assemblyBuilder.addNodes(drawingId, nodesToAdd);
                 },
-                addDimension: (dim) => {
-                    return this.resolve(async ([rProductId]) => {
-                        const dimensionType = getDimensionType(dim.dimParam.dimType);
-                        const dimParam = {
-                            productId: rProductId,
-                            param: {
-                                type: dimensionType,
-                                name: dim.dimParam.dimName,
-                                label: dim.dimParam.dimLabel,
-                                value: dim.dimParam.dimValue,
-                                startPos: dim.dimParam.dimStartPos,
-                                endPos: dim.dimParam.dimEndPos,
-                                textPos: dim.dimParam.dimTextPos,
-                                textAngle: dim.dimParam.dimTextAngle,
-                                orientation: dim.dimParam.dimOrientation,
-                                color: dim.dimParam.dimColor,
-                                layer: dim.dimParam.dimLayer,
-                            },
-                            dxfView: dim.dxfView,
-                        };
-                        return ccAPI.drawing2D.addDimension(drawingId, dimParam);
-                    }, dim.productId);
-                },
                 addDimensions: async (...dimensions) => {
                     var e_2, _a;
                     const dimParamsToAdd = [];
@@ -502,7 +459,7 @@ export default class CAD {
                             const cDrawing = await getDrawing(drawingId);
                             const sketchLines = [];
                             // TODO: Which sketch lines need to be included, is CCClasses.CCCurve and its derivation enough?
-                            sketchLines.push(...ccUtils.base.getChildren(rSketchId, CCClasses.CCCurve, cDrawing.structure.tree));
+                            sketchLines.push(...baseUtils.getChildren(rSketchId, CCClasses.CCCurve, cDrawing.structure.tree));
                             if (sketchLines) {
                                 const limit1Param = { value: limit1, isExpr: typeof limit1 === 'string' };
                                 const limit2Param = { value: limit2, isExpr: typeof limit2 === 'string' };
@@ -526,8 +483,8 @@ export default class CAD {
                         if (revolve) {
                             const cDrawing = await getDrawing(drawingId);
                             const sketchLines = [];
-                            sketchLines.push(...ccUtils.base.getChildren(rSketchId, CCClasses.CCCircle, cDrawing.structure.tree));
-                            sketchLines.push(...ccUtils.base.getChildren(rSketchId, CCClasses.CCLine, cDrawing.structure.tree));
+                            sketchLines.push(...baseUtils.getChildren(rSketchId, CCClasses.CCCircle, cDrawing.structure.tree));
+                            sketchLines.push(...baseUtils.getChildren(rSketchId, CCClasses.CCLine, cDrawing.structure.tree));
                             if (sketchLines) {
                                 const angle1Param = { value: angle1, isExpr: typeof angle1 === 'string' };
                                 const angle2Param = { value: angle2, isExpr: typeof angle2 === 'string' };
@@ -613,25 +570,25 @@ export default class CAD {
                     const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
                     const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
                     const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const constraintId = await ccAPI.assemblyBuilder.create3DConstraint(drawingId, rAsmId, CCClasses.CCFastenedConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCFastenedConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                        await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, constraintId, { matePath: rMatePath1, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, { matePath: rMatePath2, wcsId: rWcs2, flip: mate2.flip, reoriented: mate2.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
+                        await assemblyBuilderAPI.updateFastenedConstraints(drawingId, [
+                            {
+                                constrId: constraintId,
+                                mate1: { matePath: rMatePath1, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented },
+                                mate2: { matePath: rMatePath2, wcsId: rWcs2, flip: mate2.flip, reoriented: mate2.reoriented },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffset: zOffsetParam,
+                            },
+                        ]);
                         return constraintId;
                     }
                     return null;
                 },
-                updateFastenedConstraint: async (constrId, mate1, mate2, xOffset, yOffset, zOffset) => {
-                    const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constrId, mate1.wcsId, mate2.wcsId));
-                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
-                    const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
-                    const yOffsetParam = { value: yOffset, isExpr: typeof xOffset === 'string' };
-                    const zOffsetParam = { value: zOffset, isExpr: typeof xOffset === 'string' };
-                    await ccAPI.assemblyBuilder.updateFastenedConstraint(drawingId, rConstrId, { matePath: rMatePath1, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, { matePath: rMatePath2, wcsId: rWcs2, flip: mate2.flip, reoriented: mate2.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
-                },
                 updateFastenedConstraints: async (...constraints) => {
                     var e_3, _a;
                     const constrToAdd = [];
@@ -671,29 +628,29 @@ export default class CAD {
                         }
                         finally { if (e_3) throw e_3.error; }
                     }
-                    await ccAPI.assemblyBuilder.updateFastenedConstraints(drawingId, constrToAdd);
+                    await assemblyBuilderAPI.updateFastenedConstraints(drawingId, constrToAdd);
                 },
                 createFastenedOriginConstraint: async (asmId, mate1, xOffset, yOffset, zOffset, name) => {
                     const [rAsmId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId));
                     const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
-                    const constraintId = await ccAPI.assemblyBuilder.create3DConstraint(drawingId, rAsmId, CCClasses.CCFastenedOriginConstraint, name);
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCFastenedOriginConstraint, name);
                     if (constraintId != null) {
                         const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
                         const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
                         const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                        await ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, constraintId, { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
+                        await assemblyBuilderAPI.updateFastenedOriginConstraints(drawingId, [
+                            {
+                                constrId: constraintId,
+                                mate1: { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffset: zOffsetParam,
+                            },
+                        ]);
                         return constraintId;
                     }
                     return null;
                 },
-                updateFastenedOriginConstraint: async (constrId, mate1, xOffset, yOffset, zOffset) => {
-                    const [rConstrId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), constrId, mate1.wcsId));
-                    const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
-                    const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
-                    const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
-                    const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                    await ccAPI.assemblyBuilder.updateFastenedOriginConstraint(drawingId, rConstrId, { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented }, xOffsetParam, yOffsetParam, zOffsetParam);
-                },
                 updateFastenedOriginConstraints: async (...constraints) => {
                     var e_4, _a;
                     const constraintsToAdd = [];
@@ -726,7 +683,378 @@ export default class CAD {
                         }
                         finally { if (e_4) throw e_4.error; }
                     }
-                    await ccAPI.assemblyBuilder.updateFastenedOriginConstraints(drawingId, constraintsToAdd);
+                    await assemblyBuilderAPI.updateFastenedOriginConstraints(drawingId, constraintsToAdd);
+                },
+                createCylindricalConstraint: async (asmId, mate1, mate2, zOffsetLimits, zRotationLimits, name) => {
+                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCCylindricalConstraint, name);
+                    if (constraintId != null) {
+                        await assemblyBuilderAPI.updateCylindricalConstraints(drawingId, [
+                            {
+                                constrId: constraintId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: mate1.flip,
+                                    reoriented: mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: mate2.flip,
+                                    reoriented: mate2.reoriented,
+                                },
+                                zOffsetLimits,
+                                zRotationLimits,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateCylindricalConstraints: async (...constraints) => {
+                    var e_5, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_3 = __asyncValues(constraints), constraints_3_1; constraints_3_1 = await constraints_3.next(), !constraints_3_1.done;) {
+                            const constr = constraints_3_1.value;
+                            const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId, constr.mate2.wcsId));
+                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: constr.mate2.flip,
+                                    reoriented: constr.mate2.reoriented,
+                                },
+                                zOffsetLimits: constr.zOffsetLimits,
+                                zRotationLimits: constr.zRotationLimits,
+                            });
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (constraints_3_1 && !constraints_3_1.done && (_a = constraints_3.return)) await _a.call(constraints_3);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                    await assemblyBuilderAPI.updateCylindricalConstraints(drawingId, constrToAdd);
+                },
+                createRevoluteConstraint: async (asmId, mate1, mate2, zOffset, zRotationLimits, name) => {
+                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCRevoluteConstraint, name);
+                    if (constraintId != null) {
+                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
+                        await assemblyBuilderAPI.updateRevoluteConstraints(drawingId, [
+                            {
+                                constrId: constraintId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: mate1.flip,
+                                    reoriented: mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: mate2.flip,
+                                    reoriented: mate2.reoriented,
+                                },
+                                zOffset: zOffsetParam,
+                                zRotationLimits,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateRevoluteConstraints: async (...constraints) => {
+                    var e_6, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_4 = __asyncValues(constraints), constraints_4_1; constraints_4_1 = await constraints_4.next(), !constraints_4_1.done;) {
+                            const constr = constraints_4_1.value;
+                            const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId, constr.mate2.wcsId));
+                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
+                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: constr.mate2.flip,
+                                    reoriented: constr.mate2.reoriented,
+                                },
+                                zOffset: zOffsetParam,
+                                zRotationLimits: constr.zRotationLimits,
+                            });
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (constraints_4_1 && !constraints_4_1.done && (_a = constraints_4.return)) await _a.call(constraints_4);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                    await assemblyBuilderAPI.updateRevoluteConstraints(drawingId, constrToAdd);
+                },
+                createSliderConstraint: async (asmId, mate1, mate2, xOffset, yOffset, zOffsetLimits, name) => {
+                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCSliderConstraint, name);
+                    if (constraintId != null) {
+                        const xOffsetParam = { value: xOffset, isExpr: typeof xOffset === 'string' };
+                        const yOffsetParam = { value: yOffset, isExpr: typeof yOffset === 'string' };
+                        await assemblyBuilderAPI.updateSliderConstraints(drawingId, [
+                            {
+                                constrId: constraintId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: mate1.flip,
+                                    reoriented: mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: mate2.flip,
+                                    reoriented: mate2.reoriented,
+                                },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffsetLimits,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateSliderConstraints: async (...constraints) => {
+                    var e_7, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_5 = __asyncValues(constraints), constraints_5_1; constraints_5_1 = await constraints_5.next(), !constraints_5_1.done;) {
+                            const constr = constraints_5_1.value;
+                            const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId, constr.mate2.wcsId));
+                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
+                            const xOffsetParam = { value: constr.xOffset, isExpr: typeof constr.xOffset === 'string' };
+                            const yOffsetParam = { value: constr.yOffset, isExpr: typeof constr.yOffset === 'string' };
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: constr.mate2.flip,
+                                    reoriented: constr.mate2.reoriented,
+                                },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffsetLimits: constr.zOffsetLimits,
+                            });
+                        }
+                    }
+                    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                    finally {
+                        try {
+                            if (constraints_5_1 && !constraints_5_1.done && (_a = constraints_5.return)) await _a.call(constraints_5);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                    }
+                    await assemblyBuilderAPI.updateSliderConstraints(drawingId, constrToAdd);
+                },
+                createPlanarConstraint: async (asmId, mate1, mate2, zOffset, xOffsetLimits, yOffsetLimits, zRotationLimits, name) => {
+                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCPlanarConstraint, name);
+                    if (constraintId != null) {
+                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
+                        await assemblyBuilderAPI.updatePlanarConstraints(drawingId, [
+                            {
+                                constrId: constraintId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: mate1.flip,
+                                    reoriented: mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: mate2.flip,
+                                    reoriented: mate2.reoriented,
+                                },
+                                zOffset: zOffsetParam,
+                                xOffsetLimits,
+                                yOffsetLimits,
+                                zRotationLimits,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updatePlanarConstraints: async (...constraints) => {
+                    var e_8, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_6 = __asyncValues(constraints), constraints_6_1; constraints_6_1 = await constraints_6.next(), !constraints_6_1.done;) {
+                            const constr = constraints_6_1.value;
+                            const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId, constr.mate2.wcsId));
+                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
+                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: constr.mate2.flip,
+                                    reoriented: constr.mate2.reoriented,
+                                },
+                                zOffset: zOffsetParam,
+                                xOffsetLimits: constr.xOffsetLimits,
+                                yOffsetLimits: constr.yOffsetLimits,
+                                zRotationLimits: constr.zRotationLimits,
+                            });
+                        }
+                    }
+                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                    finally {
+                        try {
+                            if (constraints_6_1 && !constraints_6_1.done && (_a = constraints_6.return)) await _a.call(constraints_6);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                    }
+                    await assemblyBuilderAPI.updatePlanarConstraints(drawingId, constrToAdd);
+                },
+                createParallelConstraint: async (asmId, mate1, mate2, xOffsetLimits, yOffsetLimits, zOffsetLimits, zRotationLimits, name) => {
+                    const [rAsmId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), asmId, mate1.wcsId, mate2.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(drawingId, rAsmId, CCClasses.CCParallelConstraint, name);
+                    if (constraintId != null) {
+                        await assemblyBuilderAPI.updateParallelConstraints(drawingId, [
+                            {
+                                constrId: constraintId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: mate1.flip,
+                                    reoriented: mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: mate2.flip,
+                                    reoriented: mate2.reoriented,
+                                },
+                                xOffsetLimits,
+                                yOffsetLimits,
+                                zOffsetLimits,
+                                zRotationLimits,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateParallelConstraints: async (...constraints) => {
+                    var e_9, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_7 = __asyncValues(constraints), constraints_7_1; constraints_7_1 = await constraints_7.next(), !constraints_7_1.done;) {
+                            const constr = constraints_7_1.value;
+                            const [rConstrId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId, constr.mate2.wcsId));
+                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                mate2: {
+                                    matePath: rMatePath2,
+                                    wcsId: rWcs2,
+                                    flip: constr.mate2.flip,
+                                    reoriented: constr.mate2.reoriented,
+                                },
+                                xOffsetLimits: constr.xOffsetLimits,
+                                yOffsetLimits: constr.yOffsetLimits,
+                                zOffsetLimits: constr.zOffsetLimits,
+                                zRotationLimits: constr.zRotationLimits,
+                            });
+                        }
+                    }
+                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                    finally {
+                        try {
+                            if (constraints_7_1 && !constraints_7_1.done && (_a = constraints_7.return)) await _a.call(constraints_7);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                    }
+                    await assemblyBuilderAPI.updateParallelConstraints(drawingId, constrToAdd);
+                },
+                update3dConstraintValues: async (...constrValues) => {
+                    var e_10, _a;
+                    const constrValueParams = [];
+                    try {
+                        for (var constrValues_1 = __asyncValues(constrValues), constrValues_1_1; constrValues_1_1 = await constrValues_1.next(), !constrValues_1_1.done;) {
+                            const constrVal = constrValues_1_1.value;
+                            const [rConstrId] = await new Promise(res => this.resolve(ids => res(ids), constrVal.constrId));
+                            constrValueParams.push({
+                                constrId: rConstrId,
+                                paramName: constrVal.paramName,
+                                value: constrVal.value,
+                            });
+                        }
+                    }
+                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                    finally {
+                        try {
+                            if (constrValues_1_1 && !constrValues_1_1.done && (_a = constrValues_1.return)) await _a.call(constrValues_1);
+                        }
+                        finally { if (e_10) throw e_10.error; }
+                    }
+                    await assemblyBuilderAPI.update3DConstraintValues(drawingId, constrValueParams);
                 },
                 createBufferGeometry: async (objectId) => {
                     await this.queue;
@@ -751,16 +1079,21 @@ export default class CAD {
                     const cDrawing = getDrawing(drawingId);
                     const structureTree = cDrawing.structure.tree;
                     const scene = new Scene();
+                    const result = {
+                        nodes: [],
+                        solids: [],
+                        meshes: [],
+                    };
                     if (rObjectId != null) {
                         const rootObj = structureTree[rObjectId];
                         if (rootObj) {
-                            await createRecursiveScene(rootObj, drawingId, scene, options);
+                            await createRecursiveScene(rootObj, drawingId, scene, result, options);
                         }
                         else {
                             throw new Error('Root object does not exist!');
                         }
                     }
-                    return scene;
+                    return Object.assign({ scene }, result);
                 },
                 createExpressions: (partId, ...members) => {
                     return this.resolve(async ([rPartId]) => {
@@ -774,18 +1107,20 @@ export default class CAD {
                             };
                             membersToAdd.push({ name: mem.name, value: featureAPIParam, dataType });
                         });
-                        const success = featureAPI.updateExpressionSet(drawingId, rPartId, membersToAdd, [], []);
+                        const success = featureAPI.updateExpressionSets(drawingId, [
+                            { productId: rPartId, toAddMembers: membersToAdd, toModifyMembers: [], toDeleteList: [] },
+                        ]);
                         return success;
                     }, partId);
                 },
                 createAssemblyAsTemplate: (name) => {
                     return this.resolve(async ([]) => {
-                        return await ccAPI.assemblyBuilder.createAssemblyAsTemplate(drawingId, name);
+                        return await assemblyBuilderAPI.createAssemblyAsTemplate(drawingId, name);
                     });
                 },
                 createRootAssembly: (name) => {
                     return this.resolve(async ([]) => {
-                        return await ccAPI.assemblyBuilder.createRootAssembly(drawingId, name);
+                        return await assemblyBuilderAPI.createRootAssembly(drawingId, name);
                     });
                 },
                 createPart: (name) => {
@@ -797,21 +1132,13 @@ export default class CAD {
                 createPartAsTemplate: (name) => {
                     return this.resolve(async ([]) => {
                         const partName = name ? name : 'Part';
-                        return await ccAPI.assemblyBuilder.createPartAsTemplate(drawingId, partName);
+                        return await assemblyBuilderAPI.createPartAsTemplate(drawingId, partName);
                     });
                 },
                 createWorkAxis: (partId, type, references, position, direction, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wAName = name ? name : 'WorkAxis';
-                        const wARefs = rReferences;
-                        const wAId = await featureAPI.createWorkAxis(drawingId, rPartId, {
-                            axisType: type,
-                            references: wARefs,
-                            name: wAName,
-                            position: position,
-                            direction: direction,
-                            local: local,
-                        });
+                        const wAId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkAxis, wAName);
                         if (wAId != null) {
                             const positionParam = {
                                 value: position,
@@ -821,7 +1148,7 @@ export default class CAD {
                                 value: direction,
                                 isExpr: typeof direction === 'string',
                             };
-                            await featureAPI.updateWorkAxis(drawingId, wAId, type, wARefs, positionParam, directionParam, local);
+                            await featureAPI.updateWorkAxis(drawingId, wAId, type, rReferences, positionParam, directionParam, local);
                             return wAId;
                         }
                         return null;
@@ -830,24 +1157,14 @@ export default class CAD {
                 createWorkCoordSystem: (partId, type, references, coordinateSystem, offset, rotation, inverted, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wCSName = name ? name : 'WorkCoordSystem';
-                        const wCSRefs = rReferences;
-                        const wCSId = await featureAPI.createWorkCoordSystem(drawingId, rPartId, {
-                            coordSystemType: type,
-                            name: wCSName,
-                            references: wCSRefs,
-                            coordinateSystem,
-                            offset,
-                            rotation,
-                            inverted,
-                            local,
-                        });
+                        const wCSId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkCoordSystem, wCSName);
                         if (wCSId != null) {
                             const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
                             const rotationParam = {
                                 value: rotation,
                                 isExpr: typeof rotation === 'string',
                             };
-                            await featureAPI.updateWorkCoordSystem(drawingId, wCSId, type, wCSRefs, coordinateSystem, offsetParam, rotationParam, inverted, local);
+                            await featureAPI.updateWorkCoordSystem(drawingId, wCSId, type, rReferences, coordinateSystem, offsetParam, rotationParam, inverted, local);
                             return wCSId;
                         }
                         return null;
@@ -856,16 +1173,7 @@ export default class CAD {
                 createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wPName = name ? name : 'WorkPlane';
-                        const wPRefs = rReferences;
-                        const wPId = await featureAPI.createWorkPlane(drawingId, rPartId, {
-                            planeType: type,
-                            references: wPRefs,
-                            offsetOrAngle: offset,
-                            name: wPName,
-                            position: position,
-                            normal: normal,
-                            local: local,
-                        });
+                        const wPId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkPlane, wPName);
                         if (wPId != undefined) {
                             const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
                             const angleParam = { value: angle, isExpr: typeof angle === 'string' };
@@ -874,7 +1182,7 @@ export default class CAD {
                                 isExpr: typeof position === 'string',
                             };
                             const normalParam = { value: normal, isExpr: typeof normal === 'string' };
-                            await featureAPI.updateWorkPlane(drawingId, wPId, type, wPRefs, offsetParam, angleParam, positionParam, normalParam, local);
+                            await featureAPI.updateWorkPlane(drawingId, wPId, type, rReferences, offsetParam, angleParam, positionParam, normalParam, local);
                             return wPId;
                         }
                         return null;
@@ -883,20 +1191,13 @@ export default class CAD {
                 createWorkPoint: (partId, type, references, position, local, name) => {
                     return this.resolve(async ([rPartId, ...rReferences]) => {
                         const wPTName = name ? name : 'WorkPoint';
-                        const wPTRefs = rReferences;
-                        const wPTId = await featureAPI.createWorkPoint(drawingId, rPartId, {
-                            pointType: type,
-                            references: wPTRefs,
-                            name: wPTName,
-                            position: position,
-                            local: local,
-                        });
+                        const wPTId = await featureAPI.createWorkGeometry(drawingId, rPartId, CCClasses.CCWorkPoint, wPTName);
                         if (wPTId != undefined) {
                             const positionParam = {
                                 value: position,
                                 isExpr: typeof position === 'string',
                             };
-                            await featureAPI.updateWorkPoint(drawingId, wPTId, type, wPTRefs, positionParam, local);
+                            await featureAPI.updateWorkPoint(drawingId, wPTId, type, rReferences, positionParam, local);
                             return wPTId;
                         }
                         return null;
@@ -947,7 +1248,7 @@ export default class CAD {
                 },
                 getAssemblyFromContainer: (asmName) => {
                     return this.resolve(async ([]) => {
-                        const asmIds = ccUtils.assembly.getAssemblyFromContainer(drawingId, asmName);
+                        const asmIds = asmUtils.getAssemblyFromContainer(drawingId, asmName);
                         if (asmIds != undefined) {
                             return Array.isArray(asmIds) ? asmIds : [asmIds];
                         }
@@ -956,7 +1257,7 @@ export default class CAD {
                 },
                 getAssemblyNode: (refId, nodeName) => {
                     return this.resolve(async ([rRefId]) => {
-                        const nodeIds = ccUtils.assembly.getAssemblyNode(drawingId, rRefId, nodeName);
+                        const nodeIds = asmUtils.getAssemblyNode(drawingId, rRefId, nodeName);
                         if (nodeIds != undefined) {
                             return Array.isArray(nodeIds) ? nodeIds : [nodeIds];
                         }
@@ -965,7 +1266,7 @@ export default class CAD {
                 },
                 setCurrentNode: (refId) => {
                     return this.resolve(async ([rRefId]) => {
-                        await ccAPI.assemblyBuilder.setCurrentNode(drawingId, rRefId);
+                        await assemblyBuilderAPI.setCurrentNode(drawingId, rRefId);
                     }, refId);
                 },
                 getCurrentNode: () => {
@@ -976,7 +1277,7 @@ export default class CAD {
                 },
                 getCoordSysFromNode: (refId) => {
                     return this.resolve(async ([rRefId]) => {
-                        const coordSys = ccUtils.assembly.getCoordSysFromNode(drawingId, rRefId);
+                        const coordSys = asmUtils.getCoordSysFromNode(drawingId, rRefId);
                         if (coordSys != undefined) {
                             return coordSys;
                         }
@@ -996,7 +1297,7 @@ export default class CAD {
                 },
                 getPartFromContainer: (partName) => {
                     return this.resolve(async ([]) => {
-                        const partIds = ccUtils.assembly.getPartFromContainer(drawingId, partName);
+                        const partIds = asmUtils.getPartFromContainer(drawingId, partName);
                         if (partIds != undefined) {
                             return Array.isArray(partIds) ? partIds : [partIds];
                         }
@@ -1005,22 +1306,144 @@ export default class CAD {
                 },
                 getWorkCoordSystem: (refId, wcsName) => {
                     return this.resolve(async ([rRefId]) => {
-                        const wcsIds = ccUtils.assembly.getWorkCoordSystem(drawingId, rRefId, wcsName);
+                        console.warn('Warning: getWorkCoordSystem() is deprecated, use getWorkGeometry() instead, getWorkCoordSystem() will be removed in a future release.');
+                        const wcsIds = asmUtils.getWorkCoordSystem(drawingId, rRefId, wcsName);
                         if (wcsIds != undefined) {
                             return Array.isArray(wcsIds) ? wcsIds : [wcsIds];
                         }
                         return null;
                     }, refId);
                 },
+                getWorkGeometry: (refId, type, wgName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const wgIds = asmUtils.getWorkGeometry(drawingId, rRefId, type, wgName);
+                        if (wgIds != undefined) {
+                            return Array.isArray(wgIds) ? wgIds : [wgIds];
+                        }
+                        return null;
+                    }, refId);
+                },
                 getConstraint: (refId, constrName) => {
                     return this.resolve(async ([rRefId]) => {
-                        const constrIds = ccUtils.assembly.getConstraint(drawingId, rRefId, constrName);
+                        console.warn('Warning: getConstraint() is deprecated, use specific methods e.g. getFastenedConstraint() instead, getConstraint() will be removed in a future release.');
+                        const constrIds = asmUtils.getConstraint(drawingId, rRefId, constrName);
                         if (constrIds != undefined) {
                             return Array.isArray(constrIds) ? constrIds : [constrIds];
                         }
                         return null;
                     }, refId);
                 },
+                getFastenedConstraint: (refId, constrName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const constraint = asmUtils.getFastenedConstraint(drawingId, rRefId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                mate2: constraint.mate2,
+                                xOffset: constraint.xOffset.value,
+                                yOffset: constraint.yOffset.value,
+                                zOffset: constraint.zOffset.value,
+                            };
+                        }
+                        return null;
+                    }, refId);
+                },
+                getFastenedOriginConstraint: (refId, constrName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const constraint = asmUtils.getFastenedOriginConstraint(drawingId, rRefId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                xOffset: constraint.xOffset.value,
+                                yOffset: constraint.yOffset.value,
+                                zOffset: constraint.zOffset.value,
+                            };
+                        }
+                        return null;
+                    }, refId);
+                },
+                getRevoluteConstraint: (refId, constrName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const constraint = asmUtils.getRevoluteConstraint(drawingId, rRefId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                mate2: constraint.mate2,
+                                zOffset: constraint.zOffset.value,
+                                zRotationLimits: constraint.zRotationLimits,
+                            };
+                        }
+                        return null;
+                    }, refId);
+                },
+                getSliderConstraint: (refId, constrName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const constraint = asmUtils.getSliderConstraint(drawingId, rRefId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                mate2: constraint.mate2,
+                                xOffset: constraint.xOffset.value,
+                                yOffset: constraint.yOffset.value,
+                                zOffsetLimits: constraint.zOffsetLimits,
+                            };
+                        }
+                        return null;
+                    }, refId);
+                },
+                getPlanarConstraint: (refId, constrName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const constraint = asmUtils.getPlanarConstraint(drawingId, rRefId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                mate2: constraint.mate2,
+                                zOffset: constraint.zOffset.value,
+                                xOffsetLimits: constraint.xOffsetLimits,
+                                yOffsetLimits: constraint.yOffsetLimits,
+                                zRotationLimits: constraint.zRotationLimits,
+                            };
+                        }
+                        return null;
+                    }, refId);
+                },
+                getParallelConstraint: (refId, constrName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const constraint = asmUtils.getParallelConstraint(drawingId, rRefId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                mate2: constraint.mate2,
+                                xOffsetLimits: constraint.xOffsetLimits,
+                                yOffsetLimits: constraint.yOffsetLimits,
+                                zOffsetLimits: constraint.zOffsetLimits,
+                                zRotationLimits: constraint.zRotationLimits,
+                            };
+                        }
+                        return null;
+                    }, refId);
+                },
+                getCylindricalConstraint: (refId, constrName) => {
+                    return this.resolve(async ([rRefId]) => {
+                        const constraint = asmUtils.getCylindricalConstraint(drawingId, rRefId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                mate2: constraint.mate2,
+                                zOffsetLimits: constraint.zOffsetLimits,
+                                zRotationLimits: constraint.zRotationLimits,
+                            };
+                        }
+                        return null;
+                    }, refId);
+                },
                 getFeatureByName: (partId, featureName) => {
                     return this.resolve(async ([rProductId]) => {
                         const feature = await featureAPI.getFeatureByName(drawingId, rProductId, featureName);
@@ -1030,18 +1453,9 @@ export default class CAD {
                         return null;
                     }, partId);
                 },
-                removeNode: (referenceId, ownerId) => {
-                    return this.resolve(async ([rReferenceId, rOwnerId]) => {
-                        await ccAPI.assemblyBuilder.removeNode(drawingId, rReferenceId, rOwnerId);
-                    }, referenceId, ownerId);
-                },
                 removeNodes: (...nodes) => {
                     return this.resolve(async ([...rNodes]) => {
-                        const nodesToRemove = [];
-                        rNodes.forEach(node => {
-                            nodesToRemove.push([node.referenceId, node.ownerId]);
-                        });
-                        return ccAPI.assemblyBuilder.removeNodes(drawingId, nodesToRemove);
+                        return assemblyBuilderAPI.removeNodes(drawingId, rNodes);
                     }, ...nodes);
                 },
                 importFeature: (partId, content, format, name) => {
@@ -1064,7 +1478,7 @@ export default class CAD {
                             await featureAPI.closeFeature(drawingId, sketch);
                             const tree = getDrawing(drawingId).structure.tree;
                             const plane = tree[rPlaneId];
-                            if (plane && base.isA(plane.class, CCClasses.CCWorkPlane)) {
+                            if (plane && baseUtils.isA(plane.class, CCClasses.CCWorkPlane)) {
                                 await sketcherAPI.setWorkPlane(drawingId, sketch, rPlaneId);
                             }
                             else {
@@ -1082,7 +1496,7 @@ export default class CAD {
                             await featureAPI.closeFeature(drawingId, sketch);
                             const tree = getDrawing(drawingId).structure.tree;
                             const plane = tree[rPlaneId];
-                            if (plane && base.isA(plane.class, CCClasses.CCWorkPlane)) {
+                            if (plane && baseUtils.isA(plane.class, CCClasses.CCWorkPlane)) {
                                 await sketcherAPI.setWorkPlane(drawingId, sketch, rPlaneId);
                             }
                             else {
@@ -1100,7 +1514,7 @@ export default class CAD {
                 },
                 transformNode: (referenceId, ownerId, transformation) => {
                     return this.resolve(async ([rRefId, rOwnerId]) => {
-                        await ccAPI.assemblyBuilder.setNodeTransformation(drawingId, rRefId, rOwnerId, transformation);
+                        await assemblyBuilderAPI.setNodeTransformation(drawingId, rRefId, rOwnerId, transformation);
                     }, referenceId, ownerId);
                 },
                 translate: (partId, featureIds, references, inverted, distance) => {
@@ -1177,7 +1591,9 @@ export default class CAD {
                             };
                             membersToModify.push({ name: mem.name, value: featureAPIParam });
                         });
-                        const success = featureAPI.updateExpressionSet(drawingId, rPartId, [], membersToModify, []);
+                        const success = featureAPI.updateExpressionSets(drawingId, [
+                            { productId: rPartId, toAddMembers: [], toModifyMembers: membersToModify, toDeleteList: [] },
+                        ]);
                         return success;
                     }, partId);
                 },
@@ -1207,7 +1623,9 @@ export default class CAD {
                 },
                 deleteExpressions: (partId, members) => {
                     return this.resolve(async ([rPartId]) => {
-                        const success = featureAPI.updateExpressionSet(drawingId, rPartId, [], [], members);
+                        const success = featureAPI.updateExpressionSets(drawingId, [
+                            { productId: rPartId, toAddMembers: [], toModifyMembers: [], toDeleteList: members },
+                        ]);
                         return success;
                     }, partId);
                 },
@@ -1222,6 +1640,54 @@ export default class CAD {
                         return null;
                     }, partId, ...references);
                 },
+                mirror: async (partId, entities, references) => {
+                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
+                    const rEntities = await new Promise(res => this.resolve(ids => res(ids), ...entities));
+                    const rReferences = await new Promise(res => this.resolve(paths => res(paths), ...references));
+                    const cDrawing = getDrawing(drawingId);
+                    const entArray = [];
+                    for (const rEntity of rEntities) {
+                        const entity = cDrawing.structure.tree[rEntity].children;
+                        if (entity != undefined) {
+                            entArray.push(entity[0]);
+                        }
+                    }
+                    const mirrorId = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCMirror, 'Mirror');
+                    if (mirrorId != null) {
+                        await featureAPI.updateMirror(drawingId, mirrorId, entArray, rReferences);
+                        return mirrorId;
+                    }
+                    return null;
+                },
+                removeOperations: async (operations, toOperation) => {
+                    const rOperations = await new Promise(res => this.resolve(ids => res(ids), ...operations));
+                    const [rToOperation] = await new Promise(res => this.resolve(paths => res(paths), toOperation));
+                    if (operations && operations.length > 0) {
+                        await baseModelerAPI.deleteObjects(drawingId, rOperations);
+                    }
+                    else if (rToOperation) {
+                        const toRemoveOps = [];
+                        const cDrawing = getDrawing(drawingId);
+                        const tree = cDrawing.structure.tree;
+                        const opSeq = cDrawing.api.structure.filterTree(tree, obj => obj.name === 'OperationSequence').pop();
+                        const opRefs = opSeq && baseUtils.getChildren(opSeq.id, CCClasses.CCObjectReference, tree);
+                        const filteredOps = opRefs === null || opRefs === void 0 ? void 0 : opRefs.map(opRef => { var _a, _b; return (_b = (_a = tree[opRef].members) === null || _a === void 0 ? void 0 : _a.refObj) === null || _b === void 0 ? void 0 : _b.value; });
+                        if (filteredOps) {
+                            let opNotFound = true;
+                            let index = filteredOps.length - 2; // -2 => Avoid RollBackBar
+                            while (opNotFound) {
+                                if (filteredOps[index] !== rToOperation) {
+                                    toRemoveOps.push(filteredOps[index]);
+                                }
+                                else {
+                                    opNotFound = false;
+                                }
+                                index--;
+                            }
+                        }
+                        await baseModelerAPI.deleteObjects(drawingId, toRemoveOps);
+                    }
+                },
             };
             callback(publicApi);
             resolve(drawingId);