@buerli.io/headless 1.0.1 → 1.1.0-beta.8

package/build/esm/history.js

@@ -1,2303 +1,2303 @@
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-/* eslint-disable max-lines */
-import { createApi, CCClasses, ccUtils, DataType, SVGModusType, BuerliCadFacade, } from '@buerli.io/classcad';
-import { api, getDrawing, MathUtils, BuerliScope, createInfo, Measure, } from '@buerli.io/core';
-import { Group, Matrix4, Mesh, MeshStandardMaterial, Scene } from 'three';
-import { mergeBufferGeometries } from 'three-stdlib';
-import { waitForSelect } from './utils/selection';
-import { getDifferentColoredMeshesFromEntity } from './utils/meshes';
-/**
- * Helps to create the buffer geometry of the given object recursively.
- * @param object object to create the buffergeometry from
- * @param bufferGeomArray array to fill up with buffert geometries
- */
-const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray) => {
-    let cDrawing = getDrawing(drawingId);
-    const tree = cDrawing.structure.tree;
-    if (object.link || object.solids) {
-        // Part
-        const baseModeler = createApi(drawingId).v0.baseModeler;
-        const solids = object.link ? tree[object.link].solids : object.solids;
-        if (solids != undefined) {
-            let geometries = [];
-            for (const solid of solids) {
-                let cachedSolid = cDrawing.geometry.cache[solid];
-                if (cachedSolid) {
-                    // if solid already cached, take it from cache
-                    geometries = [...geometries, ...cachedSolid.meshes.map(m => m.geometry)];
-                }
-                else {
-                    // else get visualisation from classcad
-                    await baseModeler.requestVisualisationOfEntities([solid]);
-                    cDrawing = getDrawing(drawingId); // get current drawing state after request
-                    cachedSolid = cDrawing.geometry.cache[solid];
-                    if (cachedSolid) {
-                        geometries = [...geometries, ...cachedSolid.meshes.map(m => m.geometry)];
-                    }
-                    else {
-                        console.warn(`There is no cached entry for ${solid}!`, cDrawing.geometry.cache);
-                    }
-                }
-            }
-            if (geometries.length > 0) {
-                const transformation = cDrawing.api.structure.calculateGlobalTransformation(object.id);
-                const bufferGeom = mergeBufferGeometries(geometries);
-                bufferGeom.applyMatrix4(transformation);
-                bufferGeomArray.push(bufferGeom);
-            }
-        }
-    }
-    else if (object.children) {
-        // Assembly
-        for (const child of object.children) {
-            if (ccUtils.base.isA(tree[child].class, CCClasses.IProductReference)) {
-                await createRecursiveBufferGeometry(tree[child], drawingId, bufferGeomArray);
-            }
-        }
-    }
-};
-/**
- * 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 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, result, options) => {
-    let cDrawing = getDrawing(drawingId);
-    const tree = cDrawing.structure.tree;
-    if (object.link || object.solids) {
-        // Part
-        const baseModeler = createApi(drawingId).v0.baseModeler;
-        const entities = object.link ? tree[object.link].solids : object.solids;
-        if (entities != undefined) {
-            const part = new Group();
-            const matrix = object.coordinateSystem ? MathUtils.convertToMatrix4(object.coordinateSystem) : new Matrix4();
-            matrix.decompose(part.position, part.quaternion, part.scale);
-            part.updateMatrix();
-            part.userData = { id: object.id }; // instance id
-            part.name = object.name; // instance name
-            for (const entity of entities) {
-                let cachedEntity = cDrawing.geometry.cache[entity];
-                if (!cachedEntity) {
-                    // else get visualisation from classcad
-                    await baseModeler.requestVisualisationOfEntities([entity]);
-                    cDrawing = getDrawing(drawingId); // get current drawing state after request
-                    cachedEntity = cDrawing.geometry.cache[entity];
-                }
-                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';
-                        _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, i) => {
-                                const mesh = new Mesh();
-                                mesh.name = solidObject.name + '_' + i;
-                                mesh.userData = { id: m.graphicId }; // add graphic id to the userData
-                                if (!(options === null || options === void 0 ? void 0 : options.structureOnly)) {
-                                    mesh.geometry = m.geometry;
-                                    mesh.material = new MeshStandardMaterial({
-                                        color: m.color ? m.color : cachedEntity.color,
-                                        transparent: m.color ? m.opacity < 1 : cachedEntity.opacity < 1,
-                                        opacity: m.color ? m.opacity : cachedEntity.opacity,
-                                    });
-                                    mesh.material.name = mesh.name + '_material';
-                                    result.materials[mesh.material.name] = mesh.material;
-                                }
-                                result.nodes[mesh.name] = mesh;
-                                _solid.add(mesh);
-                            });
-                            part.add(_solid);
-                            result.nodes[_solid.name] = _solid;
-                        }
-                        else {
-                            // Merge all geometries into one mesh, sort them by color
-                            const colorMeshesMap = getDifferentColoredMeshesFromEntity(cachedEntity);
-                            const colorMeshes = Object.keys(colorMeshesMap);
-                            if (colorMeshes.length > 1) {
-                                // If the solid consists of multiple meshes we must keep the group
-                                colorMeshes.forEach((key, i) => {
-                                    const mesh = new Mesh();
-                                    mesh.name = solidObject.name + '_' + i;
-                                    mesh.userData = { id: solidObject.id }; // add solid id to the userData
-                                    if (!(options === null || options === void 0 ? void 0 : options.structureOnly)) {
-                                        mesh.geometry = mergeBufferGeometries(colorMeshesMap[key].meshes.map(m => m.geometry));
-                                        mesh.material = new MeshStandardMaterial({
-                                            color: colorMeshesMap[key].color,
-                                            transparent: colorMeshesMap[key].opacity < 1,
-                                            opacity: colorMeshesMap[key].opacity,
-                                        });
-                                        mesh.material.name = mesh.name + '_material';
-                                        result.materials[mesh.material.name] = mesh.material;
-                                    }
-                                    result.nodes[mesh.name] = mesh; // Collect mesh to return result later
-                                    _solid.add(mesh); // Add mesh to solid of the scene
-                                });
-                                part.add(_solid);
-                                result.nodes[_solid.name] = _solid;
-                            }
-                            else {
-                                // Otherwise we can use the mesh itself
-                                const key = colorMeshes[0];
-                                const mesh = new Mesh();
-                                mesh.name = solidObject.name;
-                                mesh.userData = { id: solidObject.id }; // add solid id to the userData
-                                if (!(options === null || options === void 0 ? void 0 : options.structureOnly)) {
-                                    mesh.geometry = mergeBufferGeometries(colorMeshesMap[key].meshes.map(m => m.geometry));
-                                    mesh.material = new MeshStandardMaterial({
-                                        color: colorMeshesMap[key].color,
-                                        transparent: colorMeshesMap[key].opacity < 1,
-                                        opacity: colorMeshesMap[key].opacity,
-                                    });
-                                    mesh.material.name = mesh.name + '_material';
-                                    result.materials[mesh.material.name] = mesh.material;
-                                }
-                                result.nodes[mesh.name] = mesh;
-                                part.add(mesh);
-                            }
-                        }
-                    }
-                }
-            }
-            root.add(part);
-            result.nodes[part.name] = part;
-        }
-    }
-    else if (object.children) {
-        // Assembly
-        const assembly = new Group();
-        const matrix = object.coordinateSystem ? MathUtils.convertToMatrix4(object.coordinateSystem) : new Matrix4();
-        matrix.decompose(assembly.position, assembly.quaternion, assembly.scale);
-        assembly.updateMatrix();
-        assembly.userData = { id: object.id }; // assembly root or instance id
-        assembly.name = object.name; // assembly root or instance name
-        result.nodes[assembly.name] = assembly;
-        root.add(assembly);
-        for (const child of object.children) {
-            if (ccUtils.base.isA(tree[child].class, CCClasses.IProductReference)) {
-                await createRecursiveScene(tree[child], drawingId, assembly, result, options);
-            }
-        }
-    }
-};
-const resolveVec = (value) => {
-    const valueX = Array.isArray(value) ? value[0] : value.x;
-    const valueY = Array.isArray(value) ? value[1] : value.y;
-    const valueZ = Array.isArray(value) ? value[2] : value.z;
-    if (typeof valueX === 'string' || typeof valueY === 'string' || typeof valueZ === 'string') {
-        return '{' + valueX + ',' + valueY + ',' + valueZ + '}';
-    }
-    else {
-        return { x: valueX, y: valueY, z: valueZ };
-    }
-};
-export class History {
-    constructor() {
-        this.drawingId = null;
-        this.queue = Promise.resolve(0);
-        this.queue = Promise.resolve(0);
-    }
-    resolve(callback, ...args) {
-        return (this.queue = this.queue
-            .then(() => Promise.all(args).then(callback))
-            .catch(e => {
-            // catch is necessary to avoid error promises in the queue
-        }));
-    }
-    init(callback) {
-        const promise = new Promise(async (resolve, reject) => {
-            const drawingId = await BuerliCadFacade.utils.connect('history');
-            if (!drawingId)
-                throw new Error('Connection/Drawing could not be created');
-            this.drawingId = drawingId;
-            const cc = createApi(drawingId);
-            const featureAPI = cc.v0.feature;
-            const sketcherAPI = cc.v0.sketcher;
-            const baseModelerAPI = cc.v0.baseModeler;
-            const assemblyBuilderAPI = cc.v0.assemblyBuilder;
-            const drawing2DAPI = cc.v0.drawing2D;
-            const geometryAPI = cc.v0.geometry;
-            const baseUtils = ccUtils.base;
-            const asmUtils = ccUtils.assembly;
-            const partUtils = ccUtils.part;
-            const publicApi = {
-                getDrawingId: () => drawingId,
-                getDrawing: () => getDrawing(drawingId),
-                getState: () => api.getState(),
-                setFacetingParameters: (distanceTol, angleTol) => this.resolve(async () => cc.v0.common.setFacetingParameters(distanceTol, angleTol)),
-                addInstances: async (...instances) => {
-                    var e_1, _a;
-                    const instancesToAdd = [];
-                    try {
-                        for (var instances_1 = __asyncValues(instances), instances_1_1; instances_1_1 = await instances_1.next(), !instances_1_1.done;) {
-                            const instance = instances_1_1.value;
-                            const [rProductId, rOwnerId] = await new Promise(res => this.resolve(id => res(id), instance.productId, instance.ownerId));
-                            // Looking for the productId given by an identifier or name
-                            // Priorities:
-                            //    1. Look for the identifier then for the name in the part templates
-                            //    2. Look for the identifier then for the name in the assembly templates
-                            let product = rProductId;
-                            if (typeof rProductId === 'string') {
-                                let products = asmUtils.getPartTemplate(drawingId, rProductId);
-                                if (products.length > 1) {
-                                    throw 'More than one product has been found for given name or ident: ' + rProductId;
-                                }
-                                else if (products.length < 1) {
-                                    products = asmUtils.getAssemblyTemplate(drawingId, rProductId);
-                                    if (products.length < 1) {
-                                        throw 'No product found for given name or ident: ' + rProductId;
-                                    }
-                                    else if (products.length > 1) {
-                                        throw 'More than one product has been found for given name or ident: ' + rProductId;
-                                    }
-                                }
-                                product = products[0];
-                            }
-                            let owner = rOwnerId;
-                            if (typeof rOwnerId === 'string') {
-                                owner = baseUtils.findObject(drawingId, {
-                                    ident: rOwnerId,
-                                    name: rOwnerId,
-                                });
-                                if (!owner) {
-                                    throw 'The owner to add instances on given by name or ident "' + rOwnerId + '" does not exist.';
-                                }
-                                const clazz = getDrawing(drawingId).structure.tree[owner].class;
-                                if (!baseUtils.isA(clazz, CCClasses.IProductReference) && !baseUtils.isA(clazz, CCClasses.CCAssembly)) {
-                                    throw ('The owner to add instances on given by name or ident "' +
-                                        rOwnerId +
-                                        '" is of the wrong type: "' +
-                                        clazz +
-                                        '". Make sure the owner is an instance, a root assembly or an assembly template.');
-                                }
-                            }
-                            const instanceParam = {
-                                productId: product,
-                                ownerId: owner,
-                                transformation: instance.transformation,
-                                name: instance.name,
-                                options: Object.assign(Object.assign({}, instance.options), { isLocal: true }), // in non-interactive mode, the transformation is local to the owner
-                            };
-                            instancesToAdd.push(instanceParam);
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (instances_1_1 && !instances_1_1.done && (_a = instances_1.return)) await _a.call(instances_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    return assemblyBuilderAPI.addInstances(instancesToAdd);
-                },
-                addDimensions: async (...dimensions) => {
-                    var e_2, _a;
-                    const dimParamsToAdd = [];
-                    try {
-                        for (var dimensions_1 = __asyncValues(dimensions), dimensions_1_1; dimensions_1_1 = await dimensions_1.next(), !dimensions_1_1.done;) {
-                            const dim = dimensions_1_1.value;
-                            const [rProductId] = await new Promise(res => this.resolve(id => res(id), dim.productId));
-                            switch (dim.param.type) {
-                                case CCClasses.CCLinearDimension:
-                                    const linearDimParam = Object.assign(Object.assign({}, dim), { productId: rProductId, param: Object.assign(Object.assign({}, dim.param), { startPos: resolveVec(dim.param.startPos), endPos: resolveVec(dim.param.endPos), textPos: resolveVec(dim.param.textPos) }) });
-                                    dimParamsToAdd.push(linearDimParam);
-                                    break;
-                                case CCClasses.CCRadialDimension:
-                                    const radialDimParam = Object.assign(Object.assign({}, dim), { productId: rProductId, param: Object.assign(Object.assign({}, dim.param), { centerPos: resolveVec(dim.param.centerPos), textPos: resolveVec(dim.param.textPos) }) });
-                                    dimParamsToAdd.push(radialDimParam);
-                                    break;
-                                case CCClasses.CCDiameterDimension:
-                                    const diameterDimParam = Object.assign(Object.assign({}, dim), { productId: rProductId, param: Object.assign(Object.assign({}, dim.param), { centerPos: resolveVec(dim.param.centerPos), textPos: resolveVec(dim.param.textPos) }) });
-                                    dimParamsToAdd.push(diameterDimParam);
-                                    break;
-                                case CCClasses.CCAngularDimension:
-                                    const angularDimParam = Object.assign(Object.assign({}, dim), { productId: rProductId, param: Object.assign(Object.assign({}, dim.param), { startPos: resolveVec(dim.param.startPos), endPos: resolveVec(dim.param.endPos), cornerPos: resolveVec(dim.param.cornerPos), textPos: resolveVec(dim.param.textPos) }) });
-                                    dimParamsToAdd.push(angularDimParam);
-                                    break;
-                                default:
-                                    break;
-                            }
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (dimensions_1_1 && !dimensions_1_1.done && (_a = dimensions_1.return)) await _a.call(dimensions_1);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                    return drawing2DAPI.addDimensions(dimParamsToAdd); // TODO v0 typescript error because of DimensionParam
-                },
-                create2DViews: (productId, viewTypes, viewOptions) => {
-                    return this.resolve(async ([rProductId]) => {
-                        const viewIds = await drawing2DAPI.create2DViews(rProductId, viewTypes, viewOptions);
-                        if (viewIds !== null) {
-                            await drawing2DAPI.centerAllViews(rProductId, viewTypes);
-                            return viewIds;
-                        }
-                        return null;
-                    }, productId);
-                },
-                getBoundaryBoxFromViews: (productId, viewTypes) => {
-                    return this.resolve(async ([rProductId]) => {
-                        const bbs = await drawing2DAPI.getBoundaryBoxFromViews(rProductId, viewTypes);
-                        return bbs;
-                    }, productId);
-                },
-                place2DViews: (productId, viewPositions) => {
-                    return this.resolve(async ([rProductId]) => {
-                        return drawing2DAPI.place2DViews(rProductId, viewPositions.map(({ viewType, vector }) => ({
-                            viewType,
-                            vector: resolveVec(vector),
-                        })));
-                    }, productId);
-                },
-                exportDXF: (productId, dxfTemplateFilename) => {
-                    return this.resolve(async ([rProductId]) => {
-                        return drawing2DAPI.exportDXF(rProductId, dxfTemplateFilename);
-                    }, productId);
-                },
-                exportSVG: (productId, modus, renderSize, dxfTemplateFilename) => {
-                    return this.resolve(async ([rProductId]) => {
-                        modus = modus ? modus : SVGModusType.FIT_WHOLE_DRAWING;
-                        const renderSizeParam = (renderSize === null || renderSize === void 0 ? void 0 : renderSize.x) && (renderSize === null || renderSize === void 0 ? void 0 : renderSize.y) ? [renderSize.x, renderSize.y] : undefined;
-                        return drawing2DAPI.exportSVG(rProductId, modus, renderSizeParam, dxfTemplateFilename);
-                    }, productId);
-                },
-                removeDimensions: (dimensionIds) => {
-                    return this.resolve(async ([...rDimensionIds]) => {
-                        return drawing2DAPI.removeDimensions(rDimensionIds);
-                    }, ...dimensionIds);
-                },
-                linearPattern: (partId, operations, references1, params1, references2, params2) => {
-                    return this.resolve(async ([rPartId, rOperations, rReferences1, rReferences2]) => {
-                        const patternId = await featureAPI.createFeature(rPartId, CCClasses.CCLinearPattern, 'LinearPattern');
-                        if (patternId != null) {
-                            // entities
-                            const cDrawing = await getDrawing(drawingId);
-                            const entArray = [];
-                            for (const rOperation of rOperations) {
-                                const entities = cDrawing.structure.tree[(await rOperation)].children;
-                                if (entities != undefined) {
-                                    entArray.push(entities[0]);
-                                }
-                            }
-                            const distance1Param = {
-                                value: params1.distance,
-                                isExpr: typeof params1.distance === 'string',
-                            };
-                            const count1Param = {
-                                value: params1.count,
-                                isExpr: typeof params1.count === 'string',
-                            };
-                            const params1Param = [
-                                params1.inverted,
-                                distance1Param,
-                                count1Param,
-                                params1.merged,
-                            ];
-                            let params2Param = null;
-                            if (params2) {
-                                const distance2Param = {
-                                    value: params2.distance,
-                                    isExpr: typeof params2.distance === 'string',
-                                };
-                                const count2Param = {
-                                    value: params2.count,
-                                    isExpr: typeof params2.count === 'string',
-                                };
-                                params2Param = [params2.inverted, distance2Param, count2Param];
-                            }
-                            // resolve references1
-                            const refs1 = [];
-                            let refs2 = [];
-                            for (const rRef1 of rReferences1) {
-                                refs1.push(await rRef1);
-                            }
-                            // resolve references2 if present
-                            if (rReferences2) {
-                                for (const rRef2 of rReferences2) {
-                                    refs2.push(await rRef2);
-                                }
-                            }
-                            else {
-                                refs2 = null;
-                            }
-                            await featureAPI.updatePattern(patternId, entArray, refs1, params1Param, refs2, params2Param);
-                            return patternId;
-                        }
-                        return null;
-                    }, partId, operations, references1, references2);
-                },
-                circularPattern: (partId, operations, references, params) => {
-                    return this.resolve(async ([rPartId, rOperations, ...rReferences]) => {
-                        const patternId = await featureAPI.createFeature(rPartId, CCClasses.CCCircularPattern, 'CircularPattern');
-                        if (patternId != null) {
-                            // entities
-                            const cDrawing = await getDrawing(drawingId);
-                            const entArray = [];
-                            for (const rOperation of rOperations) {
-                                const entities = cDrawing.structure.tree[(await rOperation)].children;
-                                if (entities != undefined) {
-                                    entArray.push(entities[0]);
-                                }
-                            }
-                            const angleParam = { value: params.angle, isExpr: typeof params.angle === 'string' };
-                            const countParam = { value: params.count, isExpr: typeof params.count === 'string' };
-                            const paramsParam = [
-                                params.inverted,
-                                angleParam,
-                                countParam,
-                                params.merged,
-                            ];
-                            rReferences = Array.isArray(rReferences) ? rReferences : [rReferences];
-                            await featureAPI.updatePattern(patternId, entArray, rReferences, paramsParam, null, null);
-                            return patternId;
-                        }
-                        return null;
-                    }, partId, operations, ...references);
-                },
-                extrusion: (partId, sketchOrRegionIds, type, limit1, limit2, taperAngle, direction, capEnds) => {
-                    return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
-                        const extrusion = await featureAPI.createFeature(rPartId, CCClasses.CCExtrusion, 'Extrusion');
-                        if (extrusion) {
-                            const resSketchOrRegionIds = Array.isArray(rSketchOrRegionIds)
-                                ? rSketchOrRegionIds
-                                : [rSketchOrRegionIds];
-                            if (resSketchOrRegionIds && resSketchOrRegionIds.length > 0) {
-                                const limit1Param = { value: limit1, isExpr: typeof limit1 === 'string' };
-                                const limit2Param = { value: limit2, isExpr: typeof limit2 === 'string' };
-                                const taperAngleParam = {
-                                    value: taperAngle,
-                                    isExpr: typeof taperAngle === 'string',
-                                };
-                                const resDirection = resolveVec(direction);
-                                const directionParam = {
-                                    value: resDirection,
-                                    isExpr: typeof resDirection === 'string',
-                                };
-                                await featureAPI.updateExtrusion(extrusion, resSketchOrRegionIds, type, limit1Param, limit2Param, taperAngleParam, directionParam, capEnds);
-                                return extrusion;
-                            }
-                        }
-                    }, partId, sketchOrRegionIds);
-                },
-                revolve: (partId, sketchOrRegionIds, axisIds, angle1, angle2, inverted) => {
-                    return this.resolve(async ([rPartId, rSketchOrRegionIds, ...rAxisIds]) => {
-                        const revolve = await featureAPI.createFeature(rPartId, CCClasses.CCRevolve, 'Revolve');
-                        if (revolve) {
-                            const resSketchOrRegionIds = Array.isArray(rSketchOrRegionIds)
-                                ? rSketchOrRegionIds
-                                : [rSketchOrRegionIds];
-                            if (resSketchOrRegionIds && resSketchOrRegionIds.length > 0) {
-                                const angle1Param = { value: angle1, isExpr: typeof angle1 === 'string' };
-                                const angle2Param = { value: angle2, isExpr: typeof angle2 === 'string' };
-                                await featureAPI.updateRevolve(revolve, resSketchOrRegionIds, rAxisIds, angle1Param, angle2Param, inverted);
-                                return revolve;
-                            }
-                        }
-                    }, partId, sketchOrRegionIds, ...axisIds);
-                },
-                boolean: (partId, type, operations) => {
-                    return this.resolve(async ([rPartId, rOperations]) => {
-                        const cDrawing = await getDrawing(drawingId);
-                        const entArray = [];
-                        for (const rOperation of rOperations) {
-                            const entities = cDrawing.structure.tree[(await rOperation)].children;
-                            if (entities != undefined) {
-                                entArray.push(entities[0]);
-                            }
-                        }
-                        const boolId = await featureAPI.createFeature(rPartId, CCClasses.CCUnion, 'Union');
-                        if (boolId != null) {
-                            await featureAPI.updateBooleanOperation(boolId, type, entArray);
-                            return boolId;
-                        }
-                        return null;
-                    }, partId, operations);
-                },
-                box: (partId, references, width, length, height) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const boxId = await featureAPI.createFeature(rPartId, CCClasses.CCBox, 'Box');
-                        if (boxId != null) {
-                            const widthParam = { value: width, isExpr: typeof width === 'string' };
-                            const lengthParam = { value: length, isExpr: typeof length === 'string' };
-                            const heightParam = { value: height, isExpr: typeof height === 'string' };
-                            await featureAPI.updateBox(boxId, rReferences, widthParam, lengthParam, heightParam);
-                            return boxId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                cylinder: (partId, references, diameter, height) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const cylId = await featureAPI.createFeature(rPartId, CCClasses.CCCylinder, 'Cylinder');
-                        if (cylId != null) {
-                            const diameterParam = { value: diameter, isExpr: typeof diameter === 'string' };
-                            const heightParam = { value: height, isExpr: typeof height === 'string' };
-                            await featureAPI.updateCylinder(cylId, rReferences, diameterParam, heightParam);
-                            return cylId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                chamfer: (partId, type, references, dist1, dist2, angle) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const dist1Param = { value: dist1, isExpr: typeof dist1 === 'string' };
-                        const dist2Param = { value: dist2, isExpr: typeof dist2 === 'string' };
-                        const angleParam = { value: angle, isExpr: typeof angle === 'string' };
-                        const chamferId = await featureAPI.createFeature(rPartId, CCClasses.CCChamfer, 'Chamfer');
-                        if (chamferId != null) {
-                            await featureAPI.updateChamfer(chamferId, type, rReferences, dist1Param, dist2Param, angleParam);
-                            return chamferId;
-                        }
-                        return null;
-                    }, partId, references);
-                },
-                cone: (partId, references, bDiameter, tDiameter, height) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const coneId = await featureAPI.createFeature(rPartId, CCClasses.CCCone, 'Cone');
-                        if (coneId != null) {
-                            const bDiamParam = { value: bDiameter, isExpr: typeof bDiameter === 'string' };
-                            const tDiamParam = { value: tDiameter, isExpr: typeof tDiameter === 'string' };
-                            const heightParam = { value: height, isExpr: typeof height === 'string' };
-                            await featureAPI.updateCone(coneId, rReferences, bDiamParam, tDiamParam, heightParam);
-                            return coneId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                createFastenedConstraint: async (id, mate1, mate2, xOffset, yOffset, zOffset, name, xRotation, yRotation, zRotation) => {
-                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, 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' };
-                        const xRotationParam = { value: xRotation || 0, isExpr: typeof xRotation === 'string' };
-                        const yRotationParam = { value: yRotation || 0, isExpr: typeof yRotation === 'string' };
-                        const zRotationParam = { value: zRotation || 0, isExpr: typeof zRotation === 'string' };
-                        await assemblyBuilderAPI.updateFastenedConstraints([
-                            {
-                                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,
-                                xRotation: xRotationParam,
-                                yRotation: yRotationParam,
-                                zRotation: zRotationParam,
-                            },
-                        ]);
-                        return constraintId;
-                    }
-                    return null;
-                },
-                updateFastenedConstraints: async (...constraints) => {
-                    var e_3, _a;
-                    const constrToAdd = [];
-                    try {
-                        for (var constraints_1 = __asyncValues(constraints), constraints_1_1; constraints_1_1 = await constraints_1.next(), !constraints_1_1.done;) {
-                            const constr = constraints_1_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' };
-                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
-                            const xRotationParam = {
-                                value: constr.xRotation || 0,
-                                isExpr: typeof constr.xRotation === 'string',
-                            };
-                            const yRotationParam = {
-                                value: constr.yRotation || 0,
-                                isExpr: typeof constr.yRotation === 'string',
-                            };
-                            const zRotationParam = {
-                                value: constr.zRotation || 0,
-                                isExpr: typeof constr.zRotation === '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,
-                                zOffset: zOffsetParam,
-                                xRotation: xRotationParam,
-                                yRotation: yRotationParam,
-                                zRotation: zRotationParam,
-                            });
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (constraints_1_1 && !constraints_1_1.done && (_a = constraints_1.return)) await _a.call(constraints_1);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                    await assemblyBuilderAPI.updateFastenedConstraints(constrToAdd);
-                },
-                createFastenedOriginConstraint: async (id, mate1, xOffset, yOffset, zOffset, name, xRotation, yRotation, zRotation) => {
-                    const [rId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId));
-                    const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(rId, 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' };
-                        const xRotationParam = { value: xRotation || 0, isExpr: typeof xRotation === 'string' };
-                        const yRotationParam = { value: yRotation || 0, isExpr: typeof yRotation === 'string' };
-                        const zRotationParam = { value: zRotation || 0, isExpr: typeof zRotation === 'string' };
-                        await assemblyBuilderAPI.updateFastenedOriginConstraints([
-                            {
-                                constrId: constraintId,
-                                mate1: { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented },
-                                xOffset: xOffsetParam,
-                                yOffset: yOffsetParam,
-                                zOffset: zOffsetParam,
-                                xRotation: xRotationParam,
-                                yRotation: yRotationParam,
-                                zRotation: zRotationParam,
-                            },
-                        ]);
-                        return constraintId;
-                    }
-                    return null;
-                },
-                updateFastenedOriginConstraints: async (...constraints) => {
-                    var e_4, _a;
-                    const constraintsToAdd = [];
-                    try {
-                        for (var constraints_2 = __asyncValues(constraints), constraints_2_1; constraints_2_1 = await constraints_2.next(), !constraints_2_1.done;) {
-                            const constr = constraints_2_1.value;
-                            const [rConstrId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId));
-                            const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
-                            const xOffsetParam = { value: constr.xOffset, isExpr: typeof constr.xOffset === 'string' };
-                            const yOffsetParam = { value: constr.yOffset, isExpr: typeof constr.yOffset === 'string' };
-                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
-                            const xRotationParam = {
-                                value: constr.xRotation || 0,
-                                isExpr: typeof constr.xRotation === 'string',
-                            };
-                            const yRotationParam = {
-                                value: constr.yRotation || 0,
-                                isExpr: typeof constr.yRotation === 'string',
-                            };
-                            const zRotationParam = {
-                                value: constr.zRotation || 0,
-                                isExpr: typeof constr.zRotation === 'string',
-                            };
-                            constraintsToAdd.push({
-                                constrId: rConstrId,
-                                mate1: {
-                                    matePath: rMatePath,
-                                    wcsId: rWcs1,
-                                    flip: constr.mate1.flip,
-                                    reoriented: constr.mate1.reoriented,
-                                },
-                                xOffset: xOffsetParam,
-                                yOffset: yOffsetParam,
-                                zOffset: zOffsetParam,
-                                xRotation: xRotationParam,
-                                yRotation: yRotationParam,
-                                zRotation: zRotationParam,
-                            });
-                        }
-                    }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                    finally {
-                        try {
-                            if (constraints_2_1 && !constraints_2_1.done && (_a = constraints_2.return)) await _a.call(constraints_2);
-                        }
-                        finally { if (e_4) throw e_4.error; }
-                    }
-                    await assemblyBuilderAPI.updateFastenedOriginConstraints(constraintsToAdd);
-                },
-                createCylindricalConstraint: async (id, mate1, mate2, zOffsetLimits, zRotationLimits, name) => {
-                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, CCClasses.CCCylindricalConstraint, name);
-                    if (constraintId != null) {
-                        await assemblyBuilderAPI.updateCylindricalConstraints([
-                            {
-                                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(constrToAdd);
-                },
-                createRevoluteConstraint: async (id, mate1, mate2, zOffset, zRotationLimits, name) => {
-                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, CCClasses.CCRevoluteConstraint, name);
-                    if (constraintId != null) {
-                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                        await assemblyBuilderAPI.updateRevoluteConstraints([
-                            {
-                                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(constrToAdd);
-                },
-                createSliderConstraint: async (id, mate1, mate2, xOffset, yOffset, zOffsetLimits, name) => {
-                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, 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([
-                            {
-                                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(constrToAdd);
-                },
-                createPlanarConstraint: async (id, mate1, mate2, zOffset, xOffsetLimits, yOffsetLimits, zRotationLimits, name) => {
-                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, CCClasses.CCPlanarConstraint, name);
-                    if (constraintId != null) {
-                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
-                        await assemblyBuilderAPI.updatePlanarConstraints([
-                            {
-                                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(constrToAdd);
-                },
-                createParallelConstraint: async (id, mate1, mate2, xOffsetLimits, yOffsetLimits, zOffsetLimits, zRotationLimits, name) => {
-                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, CCClasses.CCParallelConstraint, name);
-                    if (constraintId != null) {
-                        await assemblyBuilderAPI.updateParallelConstraints([
-                            {
-                                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(constrToAdd);
-                },
-                createGroupConstraint: async (id, instanceIds, name) => {
-                    const [rId] = await new Promise(res => this.resolve(ids => res(ids), id));
-                    const rInstanceIds = await new Promise(res => this.resolve(paths => res(paths), ...instanceIds));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(rId, CCClasses.CCGroupConstraint, name);
-                    if (constraintId != null) {
-                        await assemblyBuilderAPI.updateGroupConstraints([
-                            {
-                                constrId: constraintId,
-                                instanceIds: rInstanceIds,
-                            },
-                        ]);
-                        return constraintId;
-                    }
-                    return null;
-                },
-                updateGroupConstraints: async (...constraints) => {
-                    var e_10, _a;
-                    const constrToAdd = [];
-                    try {
-                        for (var constraints_8 = __asyncValues(constraints), constraints_8_1; constraints_8_1 = await constraints_8.next(), !constraints_8_1.done;) {
-                            const constr = constraints_8_1.value;
-                            const [rConstrId] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId));
-                            const rInstanceIds = await new Promise(res => this.resolve(paths => res(paths), ...constr.instanceIds));
-                            constrToAdd.push({
-                                constrId: rConstrId,
-                                instanceIds: rInstanceIds,
-                            });
-                        }
-                    }
-                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
-                    finally {
-                        try {
-                            if (constraints_8_1 && !constraints_8_1.done && (_a = constraints_8.return)) await _a.call(constraints_8);
-                        }
-                        finally { if (e_10) throw e_10.error; }
-                    }
-                    await assemblyBuilderAPI.updateGroupConstraints(constrToAdd);
-                },
-                createLinearPatternConstraint: async (id, instanceId, mate1, firstDirInstanceCount, firstDirDistance, name, mate2, secondDirInstanceCount, secondDirDistance) => {
-                    const [rId, rInstanceId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, instanceId, mate1.wcsId, mate2 === null || mate2 === void 0 ? void 0 : mate2.wcsId));
-                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
-                    let rMatePath2;
-                    if (mate2) {
-                        rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
-                    }
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(rId, CCClasses.CCLinearPatternConstraint, name);
-                    if (constraintId != null) {
-                        const firstDirInstanceCountParam = {
-                            value: firstDirInstanceCount,
-                            isExpr: typeof firstDirInstanceCount === 'string',
-                        };
-                        const firstDirDistanceParam = {
-                            value: firstDirDistance,
-                            isExpr: typeof firstDirDistance === 'string',
-                        };
-                        const secondDirInstanceCountParam = secondDirInstanceCount !== undefined
-                            ? {
-                                value: secondDirInstanceCount,
-                                isExpr: typeof secondDirInstanceCount === 'string',
-                            }
-                            : undefined;
-                        const secondDirDistanceParam = secondDirDistance !== undefined
-                            ? {
-                                value: secondDirDistance,
-                                isExpr: typeof secondDirDistance === 'string',
-                            }
-                            : undefined;
-                        await assemblyBuilderAPI.updateLinearPatternConstraints([
-                            {
-                                constrId: constraintId,
-                                instanceId: rInstanceId,
-                                mate1: {
-                                    matePath: rMatePath1,
-                                    wcsId: rWcs1,
-                                    flip: mate1.flip,
-                                    reoriented: mate1.reoriented,
-                                },
-                                firstDirInstanceCount: firstDirInstanceCountParam,
-                                firstDirDistance: firstDirDistanceParam,
-                                mate2: mate2
-                                    ? {
-                                        matePath: rMatePath2,
-                                        wcsId: rWcs2,
-                                        flip: mate2.flip,
-                                        reoriented: mate2.reoriented,
-                                    }
-                                    : undefined,
-                                secondDirInstanceCount: secondDirInstanceCountParam,
-                                secondDirDistance: secondDirDistanceParam,
-                            },
-                        ]);
-                        return constraintId;
-                    }
-                    return null;
-                },
-                updateLinearPatternConstraints: async (...constraints) => {
-                    var e_11, _a;
-                    const constrToAdd = [];
-                    try {
-                        for (var constraints_9 = __asyncValues(constraints), constraints_9_1; constraints_9_1 = await constraints_9.next(), !constraints_9_1.done;) {
-                            const constr = constraints_9_1.value;
-                            const [rConstrId, rInstanceId, rWcs1, rWcs2] = await new Promise(res => {
-                                var _a;
-                                return this.resolve(ids => res(ids), constr.constrId, constr.instanceId, constr.mate1.wcsId, (_a = constr.mate2) === null || _a === void 0 ? void 0 : _a.wcsId);
-                            });
-                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
-                            let rMatePath2;
-                            if (constr.mate2) {
-                                rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
-                            }
-                            const firstDirInstanceCountParam = {
-                                value: constr.firstDirInstanceCount,
-                                isExpr: typeof constr.firstDirInstanceCount === 'string',
-                            };
-                            const firstDirDistanceParam = {
-                                value: constr.firstDirDistance,
-                                isExpr: typeof constr.firstDirDistance === 'string',
-                            };
-                            const secondDirInstanceCountParam = constr.secondDirInstanceCount !== undefined
-                                ? {
-                                    value: constr.secondDirInstanceCount,
-                                    isExpr: typeof constr.secondDirInstanceCount === 'string',
-                                }
-                                : undefined;
-                            const secondDirDistanceParam = constr.secondDirDistance !== undefined
-                                ? {
-                                    value: constr.secondDirDistance,
-                                    isExpr: typeof constr.secondDirDistance === 'string',
-                                }
-                                : undefined;
-                            constrToAdd.push({
-                                constrId: rConstrId,
-                                instanceId: rInstanceId,
-                                mate1: {
-                                    matePath: rMatePath1,
-                                    wcsId: rWcs1,
-                                    flip: constr.mate1.flip,
-                                    reoriented: constr.mate1.reoriented,
-                                },
-                                firstDirInstanceCount: firstDirInstanceCountParam,
-                                firstDirDistance: firstDirDistanceParam,
-                                mate2: constr.mate2
-                                    ? {
-                                        matePath: rMatePath2,
-                                        wcsId: rWcs2,
-                                        flip: constr.mate2.flip,
-                                        reoriented: constr.mate2.reoriented,
-                                    }
-                                    : undefined,
-                                secondDirInstanceCount: secondDirInstanceCountParam,
-                                secondDirDistance: secondDirDistanceParam,
-                            });
-                        }
-                    }
-                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
-                    finally {
-                        try {
-                            if (constraints_9_1 && !constraints_9_1.done && (_a = constraints_9.return)) await _a.call(constraints_9);
-                        }
-                        finally { if (e_11) throw e_11.error; }
-                    }
-                    await assemblyBuilderAPI.updateLinearPatternConstraints(constrToAdd);
-                },
-                createCircularPatternConstraint: async (id, instanceId, mate1, instanceCount, angle, offset, name) => {
-                    const [rId, rInstanceId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), id, instanceId, mate1.wcsId));
-                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
-                    const constraintId = await assemblyBuilderAPI.create3DConstraint(rId, CCClasses.CCCircularPatternConstraint, name);
-                    if (constraintId != null) {
-                        const instanceCountParam = {
-                            value: instanceCount,
-                            isExpr: typeof instanceCount === 'string',
-                        };
-                        const angleParam = { value: angle, isExpr: typeof angle === 'string' };
-                        const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
-                        await assemblyBuilderAPI.updateCircularPatternConstraints([
-                            {
-                                constrId: constraintId,
-                                instanceId: rInstanceId,
-                                mate1: {
-                                    matePath: rMatePath1,
-                                    wcsId: rWcs1,
-                                    flip: mate1.flip,
-                                    reoriented: mate1.reoriented,
-                                },
-                                instanceCount: instanceCountParam,
-                                angle: angleParam,
-                                offset: offsetParam,
-                            },
-                        ]);
-                        return constraintId;
-                    }
-                    return null;
-                },
-                updateCircularPatternConstraints: async (...constraints) => {
-                    var e_12, _a;
-                    const constrToAdd = [];
-                    try {
-                        for (var constraints_10 = __asyncValues(constraints), constraints_10_1; constraints_10_1 = await constraints_10.next(), !constraints_10_1.done;) {
-                            const constr = constraints_10_1.value;
-                            const [rConstrId, rInstanceId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.instanceId, constr.mate1.wcsId));
-                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
-                            const instanceCountParam = {
-                                value: constr.instanceCount,
-                                isExpr: typeof constr.instanceCount === 'string',
-                            };
-                            const angleParam = { value: constr.angle, isExpr: typeof constr.angle === 'string' };
-                            const offsetParam = { value: constr.offset, isExpr: typeof constr.offset === 'string' };
-                            constrToAdd.push({
-                                constrId: rConstrId,
-                                instanceId: rInstanceId,
-                                mate1: {
-                                    matePath: rMatePath1,
-                                    wcsId: rWcs1,
-                                    flip: constr.mate1.flip,
-                                    reoriented: constr.mate1.reoriented,
-                                },
-                                instanceCount: instanceCountParam,
-                                angle: angleParam,
-                                offset: offsetParam,
-                            });
-                        }
-                    }
-                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
-                    finally {
-                        try {
-                            if (constraints_10_1 && !constraints_10_1.done && (_a = constraints_10.return)) await _a.call(constraints_10);
-                        }
-                        finally { if (e_12) throw e_12.error; }
-                    }
-                    await assemblyBuilderAPI.updateCircularPatternConstraints(constrToAdd);
-                },
-                update3dConstraintValues: async (...constrValues) => {
-                    var e_13, _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_13_1) { e_13 = { error: e_13_1 }; }
-                    finally {
-                        try {
-                            if (constrValues_1_1 && !constrValues_1_1.done && (_a = constrValues_1.return)) await _a.call(constrValues_1);
-                        }
-                        finally { if (e_13) throw e_13.error; }
-                    }
-                    await assemblyBuilderAPI.update3DConstraintValues(constrValueParams);
-                },
-                createBufferGeometry: async (objectId) => {
-                    await this.queue;
-                    this.queue = Promise.resolve(0);
-                    const rObjectId = await objectId;
-                    const cDrawing = getDrawing(drawingId);
-                    const structureTree = cDrawing.structure.tree;
-                    const bufferGeomArray = [];
-                    if (rObjectId != null) {
-                        const rootObj = structureTree[rObjectId];
-                        await createRecursiveBufferGeometry(rootObj, drawingId, bufferGeomArray);
-                        if (bufferGeomArray.length > 0) {
-                            return bufferGeomArray;
-                        }
-                    }
-                    return undefined;
-                },
-                createScene: async (objectId, options) => {
-                    await this.queue;
-                    this.queue = Promise.resolve(0);
-                    const cDrawing = getDrawing(drawingId);
-                    const structureTree = cDrawing.structure.tree;
-                    const rObjectId = objectId ? await objectId : cDrawing.structure.root;
-                    const scene = new Scene();
-                    const result = {
-                        nodes: {},
-                        materials: {},
-                    };
-                    if (rObjectId != null) {
-                        const rootObj = structureTree[rObjectId];
-                        if (rootObj) {
-                            await createRecursiveScene(rootObj, drawingId, scene, result, options);
-                        }
-                        else {
-                            throw new Error('Root object does not exist!');
-                        }
-                    }
-                    return Object.assign({ scene }, result);
-                },
-                createExpressions: (partId, ...members) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const membersToAdd = [];
-                        members.forEach(mem => {
-                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
-                            const dataType = DataType.REAL; // TODO: Aktuell nur Real Werte als Expression
-                            const featureAPIParam = {
-                                value: mem.value,
-                                isExpr: isExpr,
-                            };
-                            membersToAdd.push({ name: mem.name, value: featureAPIParam, dataType });
-                        });
-                        const success = featureAPI.updateExpressions([
-                            { productId: rPartId, toAddMembers: membersToAdd, toModifyMembers: [], toDeleteList: [] },
-                        ]);
-                        return success;
-                    }, partId);
-                },
-                createAssemblyAsTemplate: (name) => {
-                    return this.resolve(async ([]) => {
-                        return await assemblyBuilderAPI.createAssemblyAsTemplate(name);
-                    });
-                },
-                createRootAssembly: (name, options) => {
-                    return this.resolve(async ([]) => {
-                        return await assemblyBuilderAPI.createRootAssembly(name, options);
-                    });
-                },
-                createPart: (name) => {
-                    return this.resolve(async ([]) => {
-                        const partName = name ? name : 'Part';
-                        return await featureAPI.newPart(partName);
-                    });
-                },
-                createPartAsTemplate: (name) => {
-                    return this.resolve(async ([]) => {
-                        const partName = name ? name : 'Part';
-                        return await assemblyBuilderAPI.createPartAsTemplate(partName);
-                    });
-                },
-                createWorkAxis: (partId, type, references, position, direction, local, name) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const wAName = name ? name : 'WorkAxis';
-                        const wAId = await featureAPI.createWorkGeometry(rPartId, CCClasses.CCWorkAxis, wAName);
-                        if (wAId != null) {
-                            const resPosition = resolveVec(position);
-                            const positionParam = {
-                                value: resPosition,
-                                isExpr: typeof resPosition === 'string',
-                            };
-                            const resDirection = resolveVec(direction);
-                            const directionParam = {
-                                value: resDirection,
-                                isExpr: typeof resDirection === 'string',
-                            };
-                            await featureAPI.updateWorkAxis(wAId, type, rReferences, positionParam, directionParam, local);
-                            return wAId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                createWorkCoordSystem: (partId, type, references, offset, rotation, inverted = false, name) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const wCSName = name ? name : 'WorkCoordSystem';
-                        const wCSId = await featureAPI.createWorkGeometry(rPartId, CCClasses.CCWorkCSys, wCSName);
-                        if (wCSId != null) {
-                            const resOffset = resolveVec(offset);
-                            const offsetParam = {
-                                value: resOffset,
-                                isExpr: typeof resOffset === 'string',
-                            };
-                            const resRotation = resolveVec(rotation);
-                            const rotationParam = {
-                                value: resRotation,
-                                isExpr: typeof resRotation === 'string',
-                            };
-                            await featureAPI.updateWorkCSys(wCSId, type, rReferences, offsetParam, rotationParam, inverted ? 1 : 0);
-                            return wCSId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const wPName = name ? name : 'WorkPlane';
-                        const wPId = await featureAPI.createWorkGeometry(rPartId, CCClasses.CCWorkPlane, wPName);
-                        if (wPId != undefined) {
-                            const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
-                            const angleParam = { value: angle, isExpr: typeof angle === 'string' };
-                            const resPosition = resolveVec(position);
-                            const positionParam = {
-                                value: resPosition,
-                                isExpr: typeof resPosition === 'string',
-                            };
-                            const resNormal = resolveVec(normal);
-                            const normalParam = {
-                                value: resNormal,
-                                isExpr: typeof resNormal === 'string',
-                            };
-                            await featureAPI.updateWorkPlane(wPId, type, rReferences, offsetParam, angleParam, positionParam, normalParam, local);
-                            return wPId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                createWorkPoint: (partId, type, references, position, local, name) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const wPTName = name ? name : 'WorkPoint';
-                        const wPTId = await featureAPI.createWorkGeometry(rPartId, CCClasses.CCWorkPoint, wPTName);
-                        if (wPTId != undefined) {
-                            const resPosition = resolveVec(position);
-                            const positionParam = {
-                                value: resPosition,
-                                isExpr: typeof resPosition === 'string',
-                            };
-                            await featureAPI.updateWorkPoint(wPTId, type, rReferences, positionParam, local);
-                            return wPTId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                fillet: (partId, references, radius) => {
-                    return this.resolve(async ([rPartId, rReferences]) => {
-                        const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
-                        const filletId = await featureAPI.createFeature(rPartId, CCClasses.CCConstantRadiusFillet, 'Fillet');
-                        if (filletId != null) {
-                            await featureAPI.updateFillet(filletId, rReferences, radiusParam);
-                            return filletId;
-                        }
-                        return null;
-                    }, partId, references);
-                },
-                selectGeometry: (types, count) => {
-                    const drId = this.drawingId;
-                    return this.resolve(async ([]) => {
-                        const filter = (scope, data) => scope === BuerliScope && types.some(type => type === data);
-                        // Check count param. If not set use by default 1, else check if not < 1
-                        const lCount = count ? (count < 1 ? 1 : count) : 1;
-                        const selections = (await waitForSelect(lCount, filter, (resolveSelection, items, diff) => {
-                            if (items.length > lCount - 1) {
-                                resolveSelection(items);
-                            }
-                        }));
-                        const interactionInfos = [];
-                        for (const selection of selections) {
-                            // Get matching points from selected geometry and add to userData. TODO: Only if in part mode useful?
-                            const points = await geometryAPI.getPointsByGeometries([selection.data.graphicId]);
-                            const matrix = getDrawing(drId).api.structure.calculateGlobalTransformation(selection.data.productId);
-                            const clone = selection.data.geometry.clone().applyMatrix4(matrix);
-                            // TODO: Should the transform code be moved to something else than Measure? It's helpful for more cases than just measuring.
-                            const transformedData = Measure.transform([selection.data], drId)[0];
-                            const interactionInfo = createInfo({
-                                objectId: selection.data.container.ownerId,
-                                prodRefId: selection.data.productId,
-                                containerId: selection.data.container.id,
-                                graphicId: selection.data.graphicId,
-                                // objectPath: ?,  TODO: Add path to the root in expanded tree, as soon as available
-                                userData: Object.assign(Object.assign({}, transformedData), { geometry: clone, matchingPoints: points }),
-                            });
-                            interactionInfos.push(interactionInfo);
-                        }
-                        return interactionInfos;
-                    });
-                },
-                findGeometry: (partId, type, positions) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const geoms = await geometryAPI.findGeometriesByPoints(rPartId, type, positions.map(pos => pos.map(p => resolveVec(p))));
-                        return geoms;
-                    }, partId);
-                },
-                getAssemblyTemplate: (asmName) => {
-                    return this.resolve(async ([]) => {
-                        const asmIds = asmUtils.getAssemblyTemplate(drawingId, asmName);
-                        if (asmIds != undefined) {
-                            return Array.isArray(asmIds) ? asmIds : [asmIds];
-                        }
-                        return null;
-                    });
-                },
-                getInstance: (id, instanceName) => {
-                    return this.resolve(async ([rId]) => {
-                        const instances = asmUtils.getInstance(drawingId, rId, instanceName);
-                        if (instances != undefined) {
-                            return Array.isArray(instances) ? instances : [instances];
-                        }
-                        return null;
-                    }, id);
-                },
-                findInstance: (options) => {
-                    return this.resolve(async () => {
-                        const instance = baseUtils.findObject(drawingId, {
-                            ident: options.instanceIdent,
-                            name: options.instanceName,
-                        });
-                        if (!instance) {
-                            return null;
-                        }
-                        const clazz = getDrawing(drawingId).structure.tree[instance].class;
-                        if (!baseUtils.isA(clazz, CCClasses.IProductReference)) {
-                            return null;
-                        }
-                        else {
-                            return instance;
-                        }
-                    });
-                },
-                getProductsOfInstances: (instanceIds) => {
-                    return this.resolve(async ([rInstanceIds]) => {
-                        const drawing = getDrawing(drawingId);
-                        const tree = drawing.structure.tree;
-                        const products = [];
-                        for (const rInstanceId of rInstanceIds) {
-                            const product = asmUtils.findProduct(rInstanceId, tree);
-                            products.push(product);
-                        }
-                        return products;
-                    }, instanceIds);
-                },
-                setCurrentInstance: (id) => {
-                    return this.resolve(async ([rId]) => {
-                        await assemblyBuilderAPI.setCurrentInstance(rId);
-                    }, id);
-                },
-                getCurrentInstance: () => {
-                    return this.resolve(async () => {
-                        const drw = getDrawing(drawingId);
-                        return drw.structure.currentInstance;
-                    });
-                },
-                getTransformation: (id) => {
-                    return this.resolve(async ([rId]) => {
-                        const coordSys = asmUtils.getTransformation(drawingId, rId);
-                        if (coordSys != undefined) {
-                            return coordSys;
-                        }
-                        return null;
-                    }, id);
-                },
-                setCurrentProduct: (productId) => {
-                    return this.resolve(async ([rProductId]) => {
-                        await baseModelerAPI.setCurrentProduct(rProductId);
-                    }, productId);
-                },
-                getCurrentProduct: () => {
-                    return this.resolve(async () => {
-                        const drw = getDrawing(drawingId);
-                        return drw.structure.currentProduct;
-                    });
-                },
-                getPartTemplate: (partName) => {
-                    return this.resolve(async ([]) => {
-                        const partIds = asmUtils.getPartTemplate(drawingId, partName);
-                        if (partIds != undefined) {
-                            return Array.isArray(partIds) ? partIds : [partIds];
-                        }
-                        return null;
-                    });
-                },
-                getWorkCoordSystem: (id, wcsName) => {
-                    return this.resolve(async ([rId]) => {
-                        console.warn('Warning: getWorkCoordSystem() is deprecated, use getWorkGeometry() instead, getWorkCoordSystem() will be removed in a future release.');
-                        const wcsIds = asmUtils.getWorkCoordSystem(drawingId, rId, wcsName);
-                        if (wcsIds != undefined) {
-                            return Array.isArray(wcsIds) ? wcsIds : [wcsIds];
-                        }
-                        return null;
-                    }, id);
-                },
-                getSketchRegion: (id, sketchRegionName) => {
-                    return this.resolve(async ([rId]) => {
-                        const sRIds = partUtils.getSketchRegion(drawingId, rId, sketchRegionName);
-                        if (sRIds != undefined) {
-                            return Array.isArray(sRIds) ? sRIds : [sRIds];
-                        }
-                        return null;
-                    }, id);
-                },
-                getSketch: (id, sketchName) => {
-                    return this.resolve(async ([rId]) => {
-                        const sIds = partUtils.getSketch(drawingId, rId, sketchName);
-                        if (sIds != undefined) {
-                            return Array.isArray(sIds) ? sIds : [sIds];
-                        }
-                        return null;
-                    }, id);
-                },
-                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]) => {
-                        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: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getFastenedConstraint(drawingId, rId, 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,
-                                xRotation: constraint.xRotation.value,
-                                yRotation: constraint.yRotation.value,
-                                zRotation: constraint.zRotation.value,
-                            };
-                        }
-                        return null;
-                    }, id);
-                },
-                getFastenedOriginConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getFastenedOriginConstraint(drawingId, rId, constrName);
-                        if (constraint != undefined) {
-                            return {
-                                constrId: constraint.constrId,
-                                mate1: constraint.mate1,
-                                xOffset: constraint.xOffset.value,
-                                yOffset: constraint.yOffset.value,
-                                zOffset: constraint.zOffset.value,
-                                xRotation: constraint.xRotation.value,
-                                yRotation: constraint.yRotation.value,
-                                zRotation: constraint.zRotation.value,
-                            };
-                        }
-                        return null;
-                    }, id);
-                },
-                getRevoluteConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getRevoluteConstraint(drawingId, rId, constrName);
-                        if (constraint != undefined) {
-                            return {
-                                constrId: constraint.constrId,
-                                mate1: constraint.mate1,
-                                mate2: constraint.mate2,
-                                zOffset: constraint.zOffset.value,
-                                zRotationLimits: constraint.zRotationLimits,
-                            };
-                        }
-                        return null;
-                    }, id);
-                },
-                getSliderConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getSliderConstraint(drawingId, rId, 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;
-                    }, id);
-                },
-                getPlanarConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getPlanarConstraint(drawingId, rId, 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;
-                    }, id);
-                },
-                getParallelConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getParallelConstraint(drawingId, rId, 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;
-                    }, id);
-                },
-                getCylindricalConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getCylindricalConstraint(drawingId, rId, constrName);
-                        if (constraint != undefined) {
-                            return {
-                                constrId: constraint.constrId,
-                                mate1: constraint.mate1,
-                                mate2: constraint.mate2,
-                                zOffsetLimits: constraint.zOffsetLimits,
-                                zRotationLimits: constraint.zRotationLimits,
-                            };
-                        }
-                        return null;
-                    }, id);
-                },
-                getGroupConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getGroupConstraint(drawingId, rId, constrName);
-                        if (constraint != undefined) {
-                            return {
-                                constrId: constraint.constrId,
-                                instanceIds: constraint.instanceIds,
-                            };
-                        }
-                        return null;
-                    }, id);
-                },
-                getLinearPatternConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        var _a, _b;
-                        const constraint = asmUtils.getLinearPatternConstraint(drawingId, rId, constrName);
-                        if (constraint != undefined) {
-                            return {
-                                constrId: constraint.constrId,
-                                instanceId: constraint.instanceId,
-                                mate1: constraint.mate1,
-                                firstDirInstanceCount: constraint.firstDirInstanceCount.value,
-                                firstDirDistance: constraint.firstDirDistance.value,
-                                mate2: constraint.mate2,
-                                secondDirInstanceCount: (_a = constraint === null || constraint === void 0 ? void 0 : constraint.secondDirInstanceCount) === null || _a === void 0 ? void 0 : _a.value,
-                                secondDirDistance: (_b = constraint === null || constraint === void 0 ? void 0 : constraint.secondDirDistance) === null || _b === void 0 ? void 0 : _b.value,
-                            };
-                        }
-                        return null;
-                    }, id);
-                },
-                getCircularPatternConstraint: (id, constrName) => {
-                    return this.resolve(async ([rId]) => {
-                        const constraint = asmUtils.getCircularPatternConstraint(drawingId, rId, constrName);
-                        if (constraint != undefined) {
-                            return {
-                                constrId: constraint.constrId,
-                                instanceId: constraint.instanceId,
-                                mate1: constraint.mate1,
-                                instanceCount: constraint.instanceCount.value,
-                                angle: constraint.angle.value,
-                                offset: constraint.offset.value,
-                            };
-                        }
-                        return null;
-                    }, id);
-                },
-                getFeatureByName: (partId, featureName) => {
-                    return this.resolve(async ([rProductId]) => {
-                        const feature = await featureAPI.getFeatureByName(rProductId, featureName);
-                        if (feature !== null) {
-                            return feature;
-                        }
-                        return null;
-                    }, partId);
-                },
-                getGeometryInformation: (id) => {
-                    return this.resolve(async ([rId]) => {
-                        const values = await baseModelerAPI.getGeometryInformation(rId);
-                        if (values !== null) {
-                            return { centerOfGravity: values[0], volume: values[1] };
-                        }
-                        return null;
-                    }, id);
-                },
-                removeInstances: async (...instances) => {
-                    var e_14, _a;
-                    const instancesToRemove = [];
-                    try {
-                        for (var instances_2 = __asyncValues(instances), instances_2_1; instances_2_1 = await instances_2.next(), !instances_2_1.done;) {
-                            const instance = instances_2_1.value;
-                            const [rInstanceId] = await new Promise(res => this.resolve(id => res(id), instance.id));
-                            let instanceId = rInstanceId;
-                            if (typeof rInstanceId === 'string') {
-                                instanceId = baseUtils.findObject(drawingId, {
-                                    ident: rInstanceId,
-                                    name: rInstanceId,
-                                });
-                                if (!instanceId) {
-                                    throw 'The instance to remove given by name or ident "' + rInstanceId + '" does not exist.';
-                                }
-                                const clazz = getDrawing(drawingId).structure.tree[instanceId].class;
-                                if (!baseUtils.isA(clazz, CCClasses.IProductReference)) {
-                                    throw ('The instance to remove given by name or ident "' +
-                                        rInstanceId +
-                                        '" is of the wrong type "' +
-                                        clazz +
-                                        '". Make sure the object is an instance.');
-                                }
-                            }
-                            const instanceParam = { id: instanceId };
-                            instancesToRemove.push(instanceParam);
-                        }
-                    }
-                    catch (e_14_1) { e_14 = { error: e_14_1 }; }
-                    finally {
-                        try {
-                            if (instances_2_1 && !instances_2_1.done && (_a = instances_2.return)) await _a.call(instances_2);
-                        }
-                        finally { if (e_14) throw e_14.error; }
-                    }
-                    return assemblyBuilderAPI.removeInstances(instancesToRemove);
-                },
-                importFeature: (partId, content, format, name) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const featureName = name ? name : 'Import';
-                        const importFeatureId = await featureAPI.createFeature(rPartId, CCClasses.CCImport, featureName);
-                        if (importFeatureId !== null) {
-                            const solids = await featureAPI.updateImport(importFeatureId, content, format.toUpperCase(), featureName);
-                            if (solids !== null) {
-                                return importFeatureId;
-                            }
-                        }
-                        return null;
-                    }, partId);
-                },
-                loadSketch: (partId, stream, planeId, name) => {
-                    return this.resolve(async ([rPartId, rPlaneId]) => {
-                        const sketch = await sketcherAPI.createSketch(rPartId);
-                        if (sketch) {
-                            await featureAPI.closeFeature(sketch);
-                            const tree = getDrawing(drawingId).structure.tree;
-                            const plane = tree[rPlaneId];
-                            if (plane && baseUtils.isA(plane.class, CCClasses.CCWorkPlane)) {
-                                await sketcherAPI.setWorkPlane(sketch, rPlaneId);
-                            }
-                            else {
-                                await sketcherAPI.createAndSetWorkPlane(sketch, rPlaneId);
-                            }
-                            await sketcherAPI.loadSketch(rPartId, sketch, stream, name);
-                            return sketch;
-                        }
-                    }, partId, planeId);
-                },
-                copySketch: (partId, sketchId, planeId) => {
-                    return this.resolve(async ([rPartId, rPlaneId, rSketchId]) => {
-                        const sketch = await sketcherAPI.createSketch(rPartId);
-                        if (sketch) {
-                            await featureAPI.closeFeature(sketch);
-                            const tree = getDrawing(drawingId).structure.tree;
-                            const plane = tree[rPlaneId];
-                            if (plane && baseUtils.isA(plane.class, CCClasses.CCWorkPlane)) {
-                                await sketcherAPI.setWorkPlane(sketch, rPlaneId);
-                            }
-                            else {
-                                await sketcherAPI.createAndSetWorkPlane(sketch, rPlaneId);
-                            }
-                            await sketcherAPI.copySketch(sketch, rSketchId);
-                            return sketch;
-                        }
-                    }, partId, planeId, sketchId);
-                },
-                placeSketch: (sketchId, planeId, invertPlane, axisId, isXAxis, invertAxis, originId) => {
-                    return this.resolve(async ([rSketchId, rPlaneId, rAxisId, rOriginId]) => {
-                        await sketcherAPI.setSketchRefs(rSketchId, rPlaneId, invertPlane, rAxisId, isXAxis, invertAxis, rOriginId);
-                    }, sketchId, planeId, axisId, originId);
-                },
-                transformInstances: async (...instances) => {
-                    var e_15, _a;
-                    const instancesToTransform = [];
-                    try {
-                        for (var instances_3 = __asyncValues(instances), instances_3_1; instances_3_1 = await instances_3.next(), !instances_3_1.done;) {
-                            const instance = instances_3_1.value;
-                            const [rInstanceId] = await new Promise(res => this.resolve(id => res(id), instance.id));
-                            let instanceId = rInstanceId;
-                            if (typeof rInstanceId === 'string') {
-                                instanceId = baseUtils.findObject(drawingId, {
-                                    ident: rInstanceId,
-                                    name: rInstanceId,
-                                });
-                                if (!instanceId) {
-                                    throw 'The instance to transform given by name or ident "' + rInstanceId + '" does not exist.';
-                                }
-                                const clazz = getDrawing(drawingId).structure.tree[instanceId].class;
-                                if (!baseUtils.isA(clazz, CCClasses.IProductReference)) {
-                                    throw ('The instance to transform given by name or ident "' +
-                                        rInstanceId +
-                                        '" is of the wrong type "' +
-                                        clazz +
-                                        '". Make sure the object is an instance.');
-                                }
-                            }
-                            const instanceParam = {
-                                id: instanceId,
-                                transformation: instance.transformation,
-                                options: { isLocal: true }, // in non-interactive mode, the transformation is local to the owner
-                            };
-                            instancesToTransform.push(instanceParam);
-                        }
-                    }
-                    catch (e_15_1) { e_15 = { error: e_15_1 }; }
-                    finally {
-                        try {
-                            if (instances_3_1 && !instances_3_1.done && (_a = instances_3.return)) await _a.call(instances_3);
-                        }
-                        finally { if (e_15) throw e_15.error; }
-                    }
-                    return assemblyBuilderAPI.transformInstances(instancesToTransform);
-                },
-                translate: (partId, operations, references, inverted, distance) => {
-                    return this.resolve(async ([rPartId, rOperations, ...rReferences]) => {
-                        const translationId = await featureAPI.createFeature(rPartId, CCClasses.CCTranslation, 'Translate');
-                        if (translationId !== null) {
-                            const cDrawing = await getDrawing(drawingId);
-                            const entArray = [];
-                            for (const rOperation of rOperations) {
-                                const entities = cDrawing.structure.tree[(await rOperation)].children;
-                                if (entities != undefined) {
-                                    entArray.push(entities[0]);
-                                }
-                            }
-                            const dist = { value: distance, isExpr: typeof distance === 'string' };
-                            await featureAPI.updateTransformation(translationId, entArray, rReferences, inverted, dist);
-                            return translationId;
-                        }
-                        return null;
-                    }, partId, operations, ...references);
-                },
-                // TODO: Remove this method. Is it necessary?
-                updateTranslate: (translationId, distance) => {
-                    return this.resolve(async ([rTranslationId]) => {
-                        const cDrawing = await getDrawing(drawingId);
-                        const members = cDrawing.structure.tree[rTranslationId].members;
-                        if (members !== null && members !== undefined) {
-                            const entArray = members['bodiesToTransform'].members.map(m => m.value);
-                            const references = members['references'].members.map(m => m.value);
-                            const inverted = members['inverted'].value;
-                            const dist = distance !== null ? distance : members['translationDistance'].value;
-                            const distParam = { value: dist, isExpr: typeof distance === 'string' };
-                            await featureAPI.openFeature(rTranslationId);
-                            await featureAPI.updateTransformation(rTranslationId, entArray, references, inverted, distParam);
-                            await featureAPI.closeFeature(rTranslationId);
-                        }
-                    }, translationId);
-                },
-                save: (type) => {
-                    return baseModelerAPI.save(type);
-                },
-                saveToUrl: (url, filetype) => {
-                    return baseModelerAPI.saveToUrl(url, filetype);
-                },
-                load: (content, type, options) => {
-                    return baseModelerAPI.load(content, type, '', options);
-                },
-                loadFromUrl: (url, filetype, options) => {
-                    return baseModelerAPI.loadFromUrl(url, filetype, true, options);
-                },
-                loadProduct: (content, type, options) => {
-                    return assemblyBuilderAPI.loadProduct(content, type, options);
-                },
-                loadProductFromUrl: (url, filetype, options) => {
-                    return assemblyBuilderAPI.loadProductFromUrl(url, filetype, options);
-                },
-                pick: (partId, type, points) => {
-                    return this.resolve(async ([rPartId]) => {
-                        console.warn('Warning: pick() is deprecated, use findGeometry() instead, pick() will be removed in a future release.');
-                        const refs = await featureAPI.pick(rPartId, type, points.map(p => resolveVec(p)));
-                        if (refs != undefined) {
-                            return Array.isArray(refs) ? refs : [refs];
-                        }
-                        return null;
-                    }, partId);
-                },
-                setExpressions: async (...expressions) => {
-                    var e_16, _a;
-                    const expressionsToSet = [];
-                    try {
-                        for (var expressions_1 = __asyncValues(expressions), expressions_1_1; expressions_1_1 = await expressions_1.next(), !expressions_1_1.done;) {
-                            const expr = expressions_1_1.value;
-                            const [rPartId] = await new Promise(res => this.resolve(id => res(id), expr.partId));
-                            const membersToModify = [];
-                            expr.members.forEach((mem) => {
-                                const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen Strings
-                                const featureAPIParam = {
-                                    value: mem.value,
-                                    isExpr,
-                                };
-                                membersToModify.push({ name: mem.name, value: featureAPIParam });
-                            });
-                            // Looking for the partId given by an identifier or name
-                            let part = rPartId;
-                            if (typeof part === 'string') {
-                                const foundPart = baseUtils.findObject(drawingId, { ident: part, name: part });
-                                if (!foundPart) {
-                                    throw 'No part found to set expressions on for given name or ident: ' + part;
-                                }
-                                const clazz = getDrawing(drawingId).structure.tree[foundPart].class;
-                                if (!baseUtils.isA(clazz, CCClasses.CCPart)) {
-                                    throw ('The part to set expressions on given by name or ident "' +
-                                        part +
-                                        '" is of the wrong type "' +
-                                        clazz +
-                                        '". Make sure the object is a part.');
-                                }
-                                else {
-                                    part = foundPart;
-                                }
-                            }
-                            expressionsToSet.push({
-                                productId: part,
-                                toAddMembers: [],
-                                toModifyMembers: membersToModify,
-                                toDeleteList: [],
-                            });
-                        }
-                    }
-                    catch (e_16_1) { e_16 = { error: e_16_1 }; }
-                    finally {
-                        try {
-                            if (expressions_1_1 && !expressions_1_1.done && (_a = expressions_1.return)) await _a.call(expressions_1);
-                        }
-                        finally { if (e_16) throw e_16.error; }
-                    }
-                    const success = await featureAPI.updateExpressions(expressionsToSet);
-                    return success;
-                },
-                renameExpressions: (partId, members) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const success = featureAPI.updateExpressions([
-                            { productId: rPartId, toAddMembers: [], toModifyMembers: [], toRenameMembers: members, toDeleteList: [] },
-                        ]);
-                        return success;
-                    }, partId);
-                },
-                deleteExpressions: (partId, members) => {
-                    return this.resolve(async ([rPartId]) => {
-                        const success = featureAPI.updateExpressions([
-                            { productId: rPartId, toAddMembers: [], toModifyMembers: [], toDeleteList: members },
-                        ]);
-                        return success;
-                    }, partId);
-                },
-                sphere: (partId, references, radius) => {
-                    return this.resolve(async ([rPartId, ...rReferences]) => {
-                        const sphereId = await featureAPI.createFeature(rPartId, CCClasses.CCSphere, 'Sphere');
-                        if (sphereId != null) {
-                            const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
-                            await featureAPI.updateSphere(sphereId, rReferences, radiusParam);
-                            return sphereId;
-                        }
-                        return null;
-                    }, partId, ...references);
-                },
-                mirror: async (partId, operations, references) => {
-                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
-                    const rOperations = await new Promise(res => this.resolve(ids => res(ids), ...operations));
-                    const rReferences = await new Promise(res => this.resolve(paths => res(paths), ...references));
-                    const cDrawing = getDrawing(drawingId);
-                    const entArray = [];
-                    for (const rOperation of rOperations) {
-                        const entities = cDrawing.structure.tree[rOperation].children;
-                        if (entities != undefined) {
-                            entArray.push(entities[0]);
-                        }
-                    }
-                    const mirrorId = await featureAPI.createFeature(rPartId, CCClasses.CCMirror, 'Mirror');
-                    if (mirrorId != null) {
-                        await featureAPI.updateMirror(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(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(toRemoveOps);
-                    }
-                },
-                getMatePath: async (refId) => {
-                    return this.resolve(async ([rRefId]) => {
-                        return asmUtils.getMatePath(drawingId, rRefId);
-                    }, refId);
-                },
-                slice: async (partId, operations, reference, sideFlag) => {
-                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
-                    const rOperations = await new Promise(res => this.resolve(ids => res(ids), ...operations));
-                    const [rReference] = await new Promise(res => this.resolve(paths => res(paths), reference));
-                    const cDrawing = getDrawing(drawingId);
-                    const entArray = [];
-                    for (const rOperation of rOperations) {
-                        const entities = cDrawing.structure.tree[rOperation].children;
-                        if (entities != undefined && entities.length > 0) {
-                            entArray.push(entities[0]); // use first entity of operation
-                        }
-                    }
-                    const sliceId = await featureAPI.createFeature(rPartId, CCClasses.CCSlice, 'Slice');
-                    if (sliceId != null) {
-                        await featureAPI.openFeature(sliceId);
-                        if (entArray.length > 0) {
-                            await featureAPI.updateSlice(sliceId, entArray, rReference, sideFlag ? 1 : 0);
-                            await featureAPI.closeFeature(sliceId);
-                            return sliceId;
-                        }
-                        await featureAPI.closeFeature(sliceId);
-                        await baseModelerAPI.deleteObjects([sliceId]);
-                    }
-                    return null;
-                },
-                sliceBySheet: async (partId, operationToSlice, operationOfSheet, sideFlag) => {
-                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
-                    const [rOperationToSlice] = await new Promise(res => this.resolve(ids => res(ids), operationToSlice));
-                    const [rOperationOfSheet] = await new Promise(res => this.resolve(ids => res(ids), operationOfSheet));
-                    const entityToSlice = getDrawing(drawingId).structure.tree[rOperationToSlice].children;
-                    const entityOfSheet = getDrawing(drawingId).structure.tree[rOperationOfSheet].children;
-                    const sliceBySheetId = await featureAPI.createFeature(rPartId, CCClasses.CCSliceBySheet, 'SliceBySheet');
-                    if (sliceBySheetId != null) {
-                        await featureAPI.openFeature(sliceBySheetId);
-                        if (entityToSlice && entityToSlice.length > 0 && entityOfSheet && entityOfSheet.length > 0) {
-                            await featureAPI.updateSliceBySheet(sliceBySheetId, entityToSlice[0], entityOfSheet[0], sideFlag ? 1 : 0);
-                            await featureAPI.closeFeature(sliceBySheetId);
-                            return sliceBySheetId;
-                        }
-                        await featureAPI.closeFeature(sliceBySheetId);
-                        await baseModelerAPI.deleteObjects([sliceBySheetId]);
-                    }
-                    return null;
-                },
-                twist: async (param) => {
-                    return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
-                        const twist = await featureAPI.createFeature(rPartId, CCClasses.CCTwist, 'Twist');
-                        if (twist) {
-                            const resSketchOrRegionIds = Array.isArray(rSketchOrRegionIds)
-                                ? rSketchOrRegionIds
-                                : [rSketchOrRegionIds];
-                            if (resSketchOrRegionIds && resSketchOrRegionIds.length > 0) {
-                                const limit1Param = {
-                                    value: param.limit1,
-                                    isExpr: typeof param.limit1 === 'string',
-                                };
-                                const limit2Param = {
-                                    value: param.limit2,
-                                    isExpr: typeof param.limit2 === 'string',
-                                };
-                                const twistAngleParam = {
-                                    value: param.twistAngle,
-                                    isExpr: typeof param.twistAngle === 'string',
-                                };
-                                if (!param.direction) {
-                                    param.direction = { x: 0, y: 0, z: 1 };
-                                }
-                                if (!param.twistCenter) {
-                                    param.twistCenter = { x: 0, y: 0, z: 0 };
-                                }
-                                const resDirection = resolveVec(param.direction);
-                                const directionParam = {
-                                    value: resDirection,
-                                    isExpr: typeof resDirection === 'string',
-                                };
-                                const resTwistCenter = resolveVec(param.twistCenter);
-                                const twistCenterParam = {
-                                    value: resTwistCenter,
-                                    isExpr: typeof resTwistCenter === 'string',
-                                };
-                                await featureAPI.updateTwist(twist, resSketchOrRegionIds, param.type, limit1Param, limit2Param, directionParam, twistAngleParam, twistCenterParam, param.capEnds);
-                                return twist;
-                            }
-                        }
-                    }, param.partId, param.sketchOrRegionIds);
-                },
-            };
-            callback(publicApi);
-            resolve(drawingId);
-        });
-        return () => promise.then(drawingId => api.getState().api.removeDrawing(drawingId));
-    }
-    destroy() {
-        this.drawingId && api.getState().api.removeDrawing(this.drawingId);
-    }
-}
-export class history extends History {
-    constructor() {
-        super();
-        console.warn("Warning: 'history' is deprecated, use 'History' instead, 'history' will be removed in a future release.");
-    }
-}
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+/* eslint-disable max-lines */
+import { createApi, CCClasses, ccUtils, DataType, SVGModusType, BuerliCadFacade, } from '@buerli.io/classcad';
+import { api, getDrawing, MathUtils, BuerliScope, createInfo, Measure, } from '@buerli.io/core';
+import { Group, Matrix4, Mesh, MeshStandardMaterial, Scene } from 'three';
+import { mergeBufferGeometries } from 'three-stdlib';
+import { waitForSelect } from './utils/selection';
+import { getDifferentColoredMeshesFromEntity } from './utils/meshes';
+/**
+ * Helps to create the buffer geometry of the given object recursively.
+ * @param object object to create the buffergeometry from
+ * @param bufferGeomArray array to fill up with buffert geometries
+ */
+const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray) => {
+    let cDrawing = getDrawing(drawingId);
+    const tree = cDrawing.structure.tree;
+    if (object.link || object.solids) {
+        // Part
+        const baseModeler = createApi(drawingId).v0.baseModeler;
+        const solids = object.link ? tree[object.link].solids : object.solids;
+        if (solids != undefined) {
+            let geometries = [];
+            for (const solid of solids) {
+                let cachedSolid = cDrawing.geometry.cache[solid];
+                if (cachedSolid) {
+                    // if solid already cached, take it from cache
+                    geometries = [...geometries, ...cachedSolid.meshes.map(m => m.geometry)];
+                }
+                else {
+                    // else get visualisation from classcad
+                    await baseModeler.requestVisualisationOfEntities([solid]);
+                    cDrawing = getDrawing(drawingId); // get current drawing state after request
+                    cachedSolid = cDrawing.geometry.cache[solid];
+                    if (cachedSolid) {
+                        geometries = [...geometries, ...cachedSolid.meshes.map(m => m.geometry)];
+                    }
+                    else {
+                        console.warn(`There is no cached entry for ${solid}!`, cDrawing.geometry.cache);
+                    }
+                }
+            }
+            if (geometries.length > 0) {
+                const transformation = cDrawing.api.structure.calculateGlobalTransformation(object.id);
+                const bufferGeom = mergeBufferGeometries(geometries);
+                bufferGeom.applyMatrix4(transformation);
+                bufferGeomArray.push(bufferGeom);
+            }
+        }
+    }
+    else if (object.children) {
+        // Assembly
+        for (const child of object.children) {
+            if (ccUtils.base.isA(tree[child].class, CCClasses.IProductReference)) {
+                await createRecursiveBufferGeometry(tree[child], drawingId, bufferGeomArray);
+            }
+        }
+    }
+};
+/**
+ * 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 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, result, options) => {
+    let cDrawing = getDrawing(drawingId);
+    const tree = cDrawing.structure.tree;
+    if (object.link || object.solids) {
+        // Part
+        const baseModeler = createApi(drawingId).v0.baseModeler;
+        const entities = object.link ? tree[object.link].solids : object.solids;
+        if (entities != undefined) {
+            const part = new Group();
+            const matrix = object.coordinateSystem ? MathUtils.convertToMatrix4(object.coordinateSystem) : new Matrix4();
+            matrix.decompose(part.position, part.quaternion, part.scale);
+            part.updateMatrix();
+            part.userData = { id: object.id }; // instance id
+            part.name = object.name; // instance name
+            for (const entity of entities) {
+                let cachedEntity = cDrawing.geometry.cache[entity];
+                if (!cachedEntity) {
+                    // else get visualisation from classcad
+                    await baseModeler.requestVisualisationOfEntities([entity]);
+                    cDrawing = getDrawing(drawingId); // get current drawing state after request
+                    cachedEntity = cDrawing.geometry.cache[entity];
+                }
+                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';
+                        _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, i) => {
+                                const mesh = new Mesh();
+                                mesh.name = solidObject.name + '_' + i;
+                                mesh.userData = { id: m.graphicId }; // add graphic id to the userData
+                                if (!(options === null || options === void 0 ? void 0 : options.structureOnly)) {
+                                    mesh.geometry = m.geometry;
+                                    mesh.material = new MeshStandardMaterial({
+                                        color: m.color ? m.color : cachedEntity.color,
+                                        transparent: m.color ? m.opacity < 1 : cachedEntity.opacity < 1,
+                                        opacity: m.color ? m.opacity : cachedEntity.opacity,
+                                    });
+                                    mesh.material.name = mesh.name + '_material';
+                                    result.materials[mesh.material.name] = mesh.material;
+                                }
+                                result.nodes[mesh.name] = mesh;
+                                _solid.add(mesh);
+                            });
+                            part.add(_solid);
+                            result.nodes[_solid.name] = _solid;
+                        }
+                        else {
+                            // Merge all geometries into one mesh, sort them by color
+                            const colorMeshesMap = getDifferentColoredMeshesFromEntity(cachedEntity);
+                            const colorMeshes = Object.keys(colorMeshesMap);
+                            if (colorMeshes.length > 1) {
+                                // If the solid consists of multiple meshes we must keep the group
+                                colorMeshes.forEach((key, i) => {
+                                    const mesh = new Mesh();
+                                    mesh.name = solidObject.name + '_' + i;
+                                    mesh.userData = { id: solidObject.id }; // add solid id to the userData
+                                    if (!(options === null || options === void 0 ? void 0 : options.structureOnly)) {
+                                        mesh.geometry = mergeBufferGeometries(colorMeshesMap[key].meshes.map(m => m.geometry));
+                                        mesh.material = new MeshStandardMaterial({
+                                            color: colorMeshesMap[key].color,
+                                            transparent: colorMeshesMap[key].opacity < 1,
+                                            opacity: colorMeshesMap[key].opacity,
+                                        });
+                                        mesh.material.name = mesh.name + '_material';
+                                        result.materials[mesh.material.name] = mesh.material;
+                                    }
+                                    result.nodes[mesh.name] = mesh; // Collect mesh to return result later
+                                    _solid.add(mesh); // Add mesh to solid of the scene
+                                });
+                                part.add(_solid);
+                                result.nodes[_solid.name] = _solid;
+                            }
+                            else {
+                                // Otherwise we can use the mesh itself
+                                const key = colorMeshes[0];
+                                const mesh = new Mesh();
+                                mesh.name = solidObject.name;
+                                mesh.userData = { id: solidObject.id }; // add solid id to the userData
+                                if (!(options === null || options === void 0 ? void 0 : options.structureOnly)) {
+                                    mesh.geometry = mergeBufferGeometries(colorMeshesMap[key].meshes.map(m => m.geometry));
+                                    mesh.material = new MeshStandardMaterial({
+                                        color: colorMeshesMap[key].color,
+                                        transparent: colorMeshesMap[key].opacity < 1,
+                                        opacity: colorMeshesMap[key].opacity,
+                                    });
+                                    mesh.material.name = mesh.name + '_material';
+                                    result.materials[mesh.material.name] = mesh.material;
+                                }
+                                result.nodes[mesh.name] = mesh;
+                                part.add(mesh);
+                            }
+                        }
+                    }
+                }
+            }
+            root.add(part);
+            result.nodes[part.name] = part;
+        }
+    }
+    else if (object.children) {
+        // Assembly
+        const assembly = new Group();
+        const matrix = object.coordinateSystem ? MathUtils.convertToMatrix4(object.coordinateSystem) : new Matrix4();
+        matrix.decompose(assembly.position, assembly.quaternion, assembly.scale);
+        assembly.updateMatrix();
+        assembly.userData = { id: object.id }; // assembly root or instance id
+        assembly.name = object.name; // assembly root or instance name
+        result.nodes[assembly.name] = assembly;
+        root.add(assembly);
+        for (const child of object.children) {
+            if (ccUtils.base.isA(tree[child].class, CCClasses.IProductReference)) {
+                await createRecursiveScene(tree[child], drawingId, assembly, result, options);
+            }
+        }
+    }
+};
+const resolveVec = (value) => {
+    const valueX = Array.isArray(value) ? value[0] : value.x;
+    const valueY = Array.isArray(value) ? value[1] : value.y;
+    const valueZ = Array.isArray(value) ? value[2] : value.z;
+    if (typeof valueX === 'string' || typeof valueY === 'string' || typeof valueZ === 'string') {
+        return '{' + valueX + ',' + valueY + ',' + valueZ + '}';
+    }
+    else {
+        return { x: valueX, y: valueY, z: valueZ };
+    }
+};
+export class History {
+    constructor() {
+        this.drawingId = null;
+        this.queue = Promise.resolve(0);
+        this.queue = Promise.resolve(0);
+    }
+    resolve(callback, ...args) {
+        return (this.queue = this.queue
+            .then(() => Promise.all(args).then(callback))
+            .catch(e => {
+            // catch is necessary to avoid error promises in the queue
+        }));
+    }
+    init(callback) {
+        const promise = new Promise(async (resolve, reject) => {
+            const drawingId = await BuerliCadFacade.utils.connect('history');
+            if (!drawingId)
+                throw new Error('Connection/Drawing could not be created');
+            this.drawingId = drawingId;
+            const cc = createApi(drawingId);
+            const featureAPI = cc.v0.feature;
+            const sketcherAPI = cc.v0.sketcher;
+            const baseModelerAPI = cc.v0.baseModeler;
+            const assemblyBuilderAPI = cc.v0.assemblyBuilder;
+            const drawing2DAPI = cc.v0.drawing2D;
+            const geometryAPI = cc.v0.geometry;
+            const baseUtils = ccUtils.base;
+            const asmUtils = ccUtils.assembly;
+            const partUtils = ccUtils.part;
+            const publicApi = {
+                getDrawingId: () => drawingId,
+                getDrawing: () => getDrawing(drawingId),
+                getState: () => api.getState(),
+                setFacetingParameters: (distanceTol, angleTol) => this.resolve(async () => cc.v0.common.setFacetingParameters(distanceTol, angleTol)),
+                addInstances: async (...instances) => {
+                    var e_1, _a;
+                    const instancesToAdd = [];
+                    try {
+                        for (var instances_1 = __asyncValues(instances), instances_1_1; instances_1_1 = await instances_1.next(), !instances_1_1.done;) {
+                            const instance = instances_1_1.value;
+                            const [rProductId, rOwnerId] = await new Promise(res => this.resolve(id => res(id), instance.productId, instance.ownerId));
+                            // Looking for the productId given by an identifier or name
+                            // Priorities:
+                            //    1. Look for the identifier then for the name in the part templates
+                            //    2. Look for the identifier then for the name in the assembly templates
+                            let product = rProductId;
+                            if (typeof rProductId === 'string') {
+                                let products = asmUtils.getPartTemplate(drawingId, rProductId);
+                                if (products.length > 1) {
+                                    throw 'More than one product has been found for given name or ident: ' + rProductId;
+                                }
+                                else if (products.length < 1) {
+                                    products = asmUtils.getAssemblyTemplate(drawingId, rProductId);
+                                    if (products.length < 1) {
+                                        throw 'No product found for given name or ident: ' + rProductId;
+                                    }
+                                    else if (products.length > 1) {
+                                        throw 'More than one product has been found for given name or ident: ' + rProductId;
+                                    }
+                                }
+                                product = products[0];
+                            }
+                            let owner = rOwnerId;
+                            if (typeof rOwnerId === 'string') {
+                                owner = baseUtils.findObject(drawingId, {
+                                    ident: rOwnerId,
+                                    name: rOwnerId,
+                                });
+                                if (!owner) {
+                                    throw 'The owner to add instances on given by name or ident "' + rOwnerId + '" does not exist.';
+                                }
+                                const clazz = getDrawing(drawingId).structure.tree[owner].class;
+                                if (!baseUtils.isA(clazz, CCClasses.IProductReference) && !baseUtils.isA(clazz, CCClasses.CCAssembly)) {
+                                    throw ('The owner to add instances on given by name or ident "' +
+                                        rOwnerId +
+                                        '" is of the wrong type: "' +
+                                        clazz +
+                                        '". Make sure the owner is an instance, a root assembly or an assembly template.');
+                                }
+                            }
+                            const instanceParam = {
+                                productId: product,
+                                ownerId: owner,
+                                transformation: instance.transformation,
+                                name: instance.name,
+                                options: Object.assign(Object.assign({}, instance.options), { isLocal: true }), // in non-interactive mode, the transformation is local to the owner
+                            };
+                            instancesToAdd.push(instanceParam);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (instances_1_1 && !instances_1_1.done && (_a = instances_1.return)) await _a.call(instances_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    return assemblyBuilderAPI.addInstances(instancesToAdd);
+                },
+                addDimensions: async (...dimensions) => {
+                    var e_2, _a;
+                    const dimParamsToAdd = [];
+                    try {
+                        for (var dimensions_1 = __asyncValues(dimensions), dimensions_1_1; dimensions_1_1 = await dimensions_1.next(), !dimensions_1_1.done;) {
+                            const dim = dimensions_1_1.value;
+                            const [rProductId] = await new Promise(res => this.resolve(id => res(id), dim.productId));
+                            switch (dim.param.type) {
+                                case CCClasses.CCLinearDimension:
+                                    const linearDimParam = Object.assign(Object.assign({}, dim), { productId: rProductId, param: Object.assign(Object.assign({}, dim.param), { startPos: resolveVec(dim.param.startPos), endPos: resolveVec(dim.param.endPos), textPos: resolveVec(dim.param.textPos) }) });
+                                    dimParamsToAdd.push(linearDimParam);
+                                    break;
+                                case CCClasses.CCRadialDimension:
+                                    const radialDimParam = Object.assign(Object.assign({}, dim), { productId: rProductId, param: Object.assign(Object.assign({}, dim.param), { centerPos: resolveVec(dim.param.centerPos), textPos: resolveVec(dim.param.textPos) }) });
+                                    dimParamsToAdd.push(radialDimParam);
+                                    break;
+                                case CCClasses.CCDiameterDimension:
+                                    const diameterDimParam = Object.assign(Object.assign({}, dim), { productId: rProductId, param: Object.assign(Object.assign({}, dim.param), { centerPos: resolveVec(dim.param.centerPos), textPos: resolveVec(dim.param.textPos) }) });
+                                    dimParamsToAdd.push(diameterDimParam);
+                                    break;
+                                case CCClasses.CCAngularDimension:
+                                    const angularDimParam = Object.assign(Object.assign({}, dim), { productId: rProductId, param: Object.assign(Object.assign({}, dim.param), { startPos: resolveVec(dim.param.startPos), endPos: resolveVec(dim.param.endPos), cornerPos: resolveVec(dim.param.cornerPos), textPos: resolveVec(dim.param.textPos) }) });
+                                    dimParamsToAdd.push(angularDimParam);
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (dimensions_1_1 && !dimensions_1_1.done && (_a = dimensions_1.return)) await _a.call(dimensions_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    return drawing2DAPI.addDimensions(dimParamsToAdd); // TODO v0 typescript error because of DimensionParam
+                },
+                create2DViews: (productId, viewTypes, viewOptions) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const viewIds = await drawing2DAPI.create2DViews(rProductId, viewTypes, viewOptions);
+                        if (viewIds !== null) {
+                            await drawing2DAPI.centerAllViews(rProductId, viewTypes);
+                            return viewIds;
+                        }
+                        return null;
+                    }, productId);
+                },
+                getBoundaryBoxFromViews: (productId, viewTypes) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const bbs = await drawing2DAPI.getBoundaryBoxFromViews(rProductId, viewTypes);
+                        return bbs;
+                    }, productId);
+                },
+                place2DViews: (productId, viewPositions) => {
+                    return this.resolve(async ([rProductId]) => {
+                        return drawing2DAPI.place2DViews(rProductId, viewPositions.map(({ viewType, vector }) => ({
+                            viewType,
+                            vector: resolveVec(vector),
+                        })));
+                    }, productId);
+                },
+                exportDXF: (productId, dxfTemplateFilename) => {
+                    return this.resolve(async ([rProductId]) => {
+                        return drawing2DAPI.exportDXF(rProductId, dxfTemplateFilename);
+                    }, productId);
+                },
+                exportSVG: (productId, modus, renderSize, dxfTemplateFilename) => {
+                    return this.resolve(async ([rProductId]) => {
+                        modus = modus ? modus : SVGModusType.FIT_WHOLE_DRAWING;
+                        const renderSizeParam = (renderSize === null || renderSize === void 0 ? void 0 : renderSize.x) && (renderSize === null || renderSize === void 0 ? void 0 : renderSize.y) ? [renderSize.x, renderSize.y] : undefined;
+                        return drawing2DAPI.exportSVG(rProductId, modus, renderSizeParam, dxfTemplateFilename);
+                    }, productId);
+                },
+                removeDimensions: (dimensionIds) => {
+                    return this.resolve(async ([...rDimensionIds]) => {
+                        return drawing2DAPI.removeDimensions(rDimensionIds);
+                    }, ...dimensionIds);
+                },
+                linearPattern: (partId, operations, references1, params1, references2, params2) => {
+                    return this.resolve(async ([rPartId, rOperations, rReferences1, rReferences2]) => {
+                        const patternId = await featureAPI.createFeature(rPartId, CCClasses.CCLinearPattern, 'LinearPattern');
+                        if (patternId != null) {
+                            // entities
+                            const cDrawing = await getDrawing(drawingId);
+                            const entArray = [];
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
+                                }
+                            }
+                            const distance1Param = {
+                                value: params1.distance,
+                                isExpr: typeof params1.distance === 'string',
+                            };
+                            const count1Param = {
+                                value: params1.count,
+                                isExpr: typeof params1.count === 'string',
+                            };
+                            const params1Param = [
+                                params1.inverted,
+                                distance1Param,
+                                count1Param,
+                                params1.merged,
+                            ];
+                            let params2Param = null;
+                            if (params2) {
+                                const distance2Param = {
+                                    value: params2.distance,
+                                    isExpr: typeof params2.distance === 'string',
+                                };
+                                const count2Param = {
+                                    value: params2.count,
+                                    isExpr: typeof params2.count === 'string',
+                                };
+                                params2Param = [params2.inverted, distance2Param, count2Param];
+                            }
+                            // resolve references1
+                            const refs1 = [];
+                            let refs2 = [];
+                            for (const rRef1 of rReferences1) {
+                                refs1.push(await rRef1);
+                            }
+                            // resolve references2 if present
+                            if (rReferences2) {
+                                for (const rRef2 of rReferences2) {
+                                    refs2.push(await rRef2);
+                                }
+                            }
+                            else {
+                                refs2 = null;
+                            }
+                            await featureAPI.updatePattern(patternId, entArray, refs1, params1Param, refs2, params2Param);
+                            return patternId;
+                        }
+                        return null;
+                    }, partId, operations, references1, references2);
+                },
+                circularPattern: (partId, operations, references, params) => {
+                    return this.resolve(async ([rPartId, rOperations, ...rReferences]) => {
+                        const patternId = await featureAPI.createFeature(rPartId, CCClasses.CCCircularPattern, 'CircularPattern');
+                        if (patternId != null) {
+                            // entities
+                            const cDrawing = await getDrawing(drawingId);
+                            const entArray = [];
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
+                                }
+                            }
+                            const angleParam = { value: params.angle, isExpr: typeof params.angle === 'string' };
+                            const countParam = { value: params.count, isExpr: typeof params.count === 'string' };
+                            const paramsParam = [
+                                params.inverted,
+                                angleParam,
+                                countParam,
+                                params.merged,
+                            ];
+                            rReferences = Array.isArray(rReferences) ? rReferences : [rReferences];
+                            await featureAPI.updatePattern(patternId, entArray, rReferences, paramsParam, null, null);
+                            return patternId;
+                        }
+                        return null;
+                    }, partId, operations, ...references);
+                },
+                extrusion: (partId, sketchOrRegionIds, type, limit1, limit2, taperAngle, direction, capEnds) => {
+                    return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
+                        const extrusion = await featureAPI.createFeature(rPartId, CCClasses.CCExtrusion, 'Extrusion');
+                        if (extrusion) {
+                            const resSketchOrRegionIds = Array.isArray(rSketchOrRegionIds)
+                                ? rSketchOrRegionIds
+                                : [rSketchOrRegionIds];
+                            if (resSketchOrRegionIds && resSketchOrRegionIds.length > 0) {
+                                const limit1Param = { value: limit1, isExpr: typeof limit1 === 'string' };
+                                const limit2Param = { value: limit2, isExpr: typeof limit2 === 'string' };
+                                const taperAngleParam = {
+                                    value: taperAngle,
+                                    isExpr: typeof taperAngle === 'string',
+                                };
+                                const resDirection = resolveVec(direction);
+                                const directionParam = {
+                                    value: resDirection,
+                                    isExpr: typeof resDirection === 'string',
+                                };
+                                await featureAPI.updateExtrusion(extrusion, resSketchOrRegionIds, type, limit1Param, limit2Param, taperAngleParam, directionParam, capEnds);
+                                return extrusion;
+                            }
+                        }
+                    }, partId, sketchOrRegionIds);
+                },
+                revolve: (partId, sketchOrRegionIds, axisIds, angle1, angle2, inverted) => {
+                    return this.resolve(async ([rPartId, rSketchOrRegionIds, ...rAxisIds]) => {
+                        const revolve = await featureAPI.createFeature(rPartId, CCClasses.CCRevolve, 'Revolve');
+                        if (revolve) {
+                            const resSketchOrRegionIds = Array.isArray(rSketchOrRegionIds)
+                                ? rSketchOrRegionIds
+                                : [rSketchOrRegionIds];
+                            if (resSketchOrRegionIds && resSketchOrRegionIds.length > 0) {
+                                const angle1Param = { value: angle1, isExpr: typeof angle1 === 'string' };
+                                const angle2Param = { value: angle2, isExpr: typeof angle2 === 'string' };
+                                await featureAPI.updateRevolve(revolve, resSketchOrRegionIds, rAxisIds, angle1Param, angle2Param, inverted);
+                                return revolve;
+                            }
+                        }
+                    }, partId, sketchOrRegionIds, ...axisIds);
+                },
+                boolean: (partId, type, operations) => {
+                    return this.resolve(async ([rPartId, rOperations]) => {
+                        const cDrawing = await getDrawing(drawingId);
+                        const entArray = [];
+                        for (const rOperation of rOperations) {
+                            const entities = cDrawing.structure.tree[(await rOperation)].children;
+                            if (entities != undefined) {
+                                entArray.push(entities[0]);
+                            }
+                        }
+                        const boolId = await featureAPI.createFeature(rPartId, CCClasses.CCUnion, 'Union');
+                        if (boolId != null) {
+                            await featureAPI.updateBooleanOperation(boolId, type, entArray);
+                            return boolId;
+                        }
+                        return null;
+                    }, partId, operations);
+                },
+                box: (partId, references, width, length, height) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const boxId = await featureAPI.createFeature(rPartId, CCClasses.CCBox, 'Box');
+                        if (boxId != null) {
+                            const widthParam = { value: width, isExpr: typeof width === 'string' };
+                            const lengthParam = { value: length, isExpr: typeof length === 'string' };
+                            const heightParam = { value: height, isExpr: typeof height === 'string' };
+                            await featureAPI.updateBox(boxId, rReferences, widthParam, lengthParam, heightParam);
+                            return boxId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                cylinder: (partId, references, diameter, height) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const cylId = await featureAPI.createFeature(rPartId, CCClasses.CCCylinder, 'Cylinder');
+                        if (cylId != null) {
+                            const diameterParam = { value: diameter, isExpr: typeof diameter === 'string' };
+                            const heightParam = { value: height, isExpr: typeof height === 'string' };
+                            await featureAPI.updateCylinder(cylId, rReferences, diameterParam, heightParam);
+                            return cylId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                chamfer: (partId, type, references, dist1, dist2, angle) => {
+                    return this.resolve(async ([rPartId, rReferences]) => {
+                        const dist1Param = { value: dist1, isExpr: typeof dist1 === 'string' };
+                        const dist2Param = { value: dist2, isExpr: typeof dist2 === 'string' };
+                        const angleParam = { value: angle, isExpr: typeof angle === 'string' };
+                        const chamferId = await featureAPI.createFeature(rPartId, CCClasses.CCChamfer, 'Chamfer');
+                        if (chamferId != null) {
+                            await featureAPI.updateChamfer(chamferId, type, rReferences, dist1Param, dist2Param, angleParam);
+                            return chamferId;
+                        }
+                        return null;
+                    }, partId, references);
+                },
+                cone: (partId, references, bDiameter, tDiameter, height) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const coneId = await featureAPI.createFeature(rPartId, CCClasses.CCCone, 'Cone');
+                        if (coneId != null) {
+                            const bDiamParam = { value: bDiameter, isExpr: typeof bDiameter === 'string' };
+                            const tDiamParam = { value: tDiameter, isExpr: typeof tDiameter === 'string' };
+                            const heightParam = { value: height, isExpr: typeof height === 'string' };
+                            await featureAPI.updateCone(coneId, rReferences, bDiamParam, tDiamParam, heightParam);
+                            return coneId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                createFastenedConstraint: async (id, mate1, mate2, xOffset, yOffset, zOffset, name, xRotation, yRotation, zRotation) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, 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' };
+                        const xRotationParam = { value: xRotation || 0, isExpr: typeof xRotation === 'string' };
+                        const yRotationParam = { value: yRotation || 0, isExpr: typeof yRotation === 'string' };
+                        const zRotationParam = { value: zRotation || 0, isExpr: typeof zRotation === 'string' };
+                        await assemblyBuilderAPI.updateFastenedConstraints([
+                            {
+                                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,
+                                xRotation: xRotationParam,
+                                yRotation: yRotationParam,
+                                zRotation: zRotationParam,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateFastenedConstraints: async (...constraints) => {
+                    var e_3, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_1 = __asyncValues(constraints), constraints_1_1; constraints_1_1 = await constraints_1.next(), !constraints_1_1.done;) {
+                            const constr = constraints_1_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' };
+                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
+                            const xRotationParam = {
+                                value: constr.xRotation || 0,
+                                isExpr: typeof constr.xRotation === 'string',
+                            };
+                            const yRotationParam = {
+                                value: constr.yRotation || 0,
+                                isExpr: typeof constr.yRotation === 'string',
+                            };
+                            const zRotationParam = {
+                                value: constr.zRotation || 0,
+                                isExpr: typeof constr.zRotation === '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,
+                                zOffset: zOffsetParam,
+                                xRotation: xRotationParam,
+                                yRotation: yRotationParam,
+                                zRotation: zRotationParam,
+                            });
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (constraints_1_1 && !constraints_1_1.done && (_a = constraints_1.return)) await _a.call(constraints_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    await assemblyBuilderAPI.updateFastenedConstraints(constrToAdd);
+                },
+                createFastenedOriginConstraint: async (id, mate1, xOffset, yOffset, zOffset, name, xRotation, yRotation, zRotation) => {
+                    const [rId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), id, mate1.wcsId));
+                    const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(rId, 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' };
+                        const xRotationParam = { value: xRotation || 0, isExpr: typeof xRotation === 'string' };
+                        const yRotationParam = { value: yRotation || 0, isExpr: typeof yRotation === 'string' };
+                        const zRotationParam = { value: zRotation || 0, isExpr: typeof zRotation === 'string' };
+                        await assemblyBuilderAPI.updateFastenedOriginConstraints([
+                            {
+                                constrId: constraintId,
+                                mate1: { matePath: rMatePath, wcsId: rWcs1, flip: mate1.flip, reoriented: mate1.reoriented },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffset: zOffsetParam,
+                                xRotation: xRotationParam,
+                                yRotation: yRotationParam,
+                                zRotation: zRotationParam,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateFastenedOriginConstraints: async (...constraints) => {
+                    var e_4, _a;
+                    const constraintsToAdd = [];
+                    try {
+                        for (var constraints_2 = __asyncValues(constraints), constraints_2_1; constraints_2_1 = await constraints_2.next(), !constraints_2_1.done;) {
+                            const constr = constraints_2_1.value;
+                            const [rConstrId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.mate1.wcsId));
+                            const rMatePath = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const xOffsetParam = { value: constr.xOffset, isExpr: typeof constr.xOffset === 'string' };
+                            const yOffsetParam = { value: constr.yOffset, isExpr: typeof constr.yOffset === 'string' };
+                            const zOffsetParam = { value: constr.zOffset, isExpr: typeof constr.zOffset === 'string' };
+                            const xRotationParam = {
+                                value: constr.xRotation || 0,
+                                isExpr: typeof constr.xRotation === 'string',
+                            };
+                            const yRotationParam = {
+                                value: constr.yRotation || 0,
+                                isExpr: typeof constr.yRotation === 'string',
+                            };
+                            const zRotationParam = {
+                                value: constr.zRotation || 0,
+                                isExpr: typeof constr.zRotation === 'string',
+                            };
+                            constraintsToAdd.push({
+                                constrId: rConstrId,
+                                mate1: {
+                                    matePath: rMatePath,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                xOffset: xOffsetParam,
+                                yOffset: yOffsetParam,
+                                zOffset: zOffsetParam,
+                                xRotation: xRotationParam,
+                                yRotation: yRotationParam,
+                                zRotation: zRotationParam,
+                            });
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (constraints_2_1 && !constraints_2_1.done && (_a = constraints_2.return)) await _a.call(constraints_2);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                    await assemblyBuilderAPI.updateFastenedOriginConstraints(constraintsToAdd);
+                },
+                createCylindricalConstraint: async (id, mate1, mate2, zOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, CCClasses.CCCylindricalConstraint, name);
+                    if (constraintId != null) {
+                        await assemblyBuilderAPI.updateCylindricalConstraints([
+                            {
+                                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(constrToAdd);
+                },
+                createRevoluteConstraint: async (id, mate1, mate2, zOffset, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, CCClasses.CCRevoluteConstraint, name);
+                    if (constraintId != null) {
+                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
+                        await assemblyBuilderAPI.updateRevoluteConstraints([
+                            {
+                                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(constrToAdd);
+                },
+                createSliderConstraint: async (id, mate1, mate2, xOffset, yOffset, zOffsetLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, 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([
+                            {
+                                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(constrToAdd);
+                },
+                createPlanarConstraint: async (id, mate1, mate2, zOffset, xOffsetLimits, yOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, CCClasses.CCPlanarConstraint, name);
+                    if (constraintId != null) {
+                        const zOffsetParam = { value: zOffset, isExpr: typeof zOffset === 'string' };
+                        await assemblyBuilderAPI.updatePlanarConstraints([
+                            {
+                                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(constrToAdd);
+                },
+                createParallelConstraint: async (id, mate1, mate2, xOffsetLimits, yOffsetLimits, zOffsetLimits, zRotationLimits, name) => {
+                    const [rId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, 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(rId, CCClasses.CCParallelConstraint, name);
+                    if (constraintId != null) {
+                        await assemblyBuilderAPI.updateParallelConstraints([
+                            {
+                                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(constrToAdd);
+                },
+                createGroupConstraint: async (id, instanceIds, name) => {
+                    const [rId] = await new Promise(res => this.resolve(ids => res(ids), id));
+                    const rInstanceIds = await new Promise(res => this.resolve(paths => res(paths), ...instanceIds));
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(rId, CCClasses.CCGroupConstraint, name);
+                    if (constraintId != null) {
+                        await assemblyBuilderAPI.updateGroupConstraints([
+                            {
+                                constrId: constraintId,
+                                instanceIds: rInstanceIds,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateGroupConstraints: async (...constraints) => {
+                    var e_10, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_8 = __asyncValues(constraints), constraints_8_1; constraints_8_1 = await constraints_8.next(), !constraints_8_1.done;) {
+                            const constr = constraints_8_1.value;
+                            const [rConstrId] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId));
+                            const rInstanceIds = await new Promise(res => this.resolve(paths => res(paths), ...constr.instanceIds));
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                instanceIds: rInstanceIds,
+                            });
+                        }
+                    }
+                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                    finally {
+                        try {
+                            if (constraints_8_1 && !constraints_8_1.done && (_a = constraints_8.return)) await _a.call(constraints_8);
+                        }
+                        finally { if (e_10) throw e_10.error; }
+                    }
+                    await assemblyBuilderAPI.updateGroupConstraints(constrToAdd);
+                },
+                createLinearPatternConstraint: async (id, instanceId, mate1, firstDirInstanceCount, firstDirDistance, name, mate2, secondDirInstanceCount, secondDirDistance) => {
+                    const [rId, rInstanceId, rWcs1, rWcs2] = await new Promise(res => this.resolve(ids => res(ids), id, instanceId, mate1.wcsId, mate2 === null || mate2 === void 0 ? void 0 : mate2.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    let rMatePath2;
+                    if (mate2) {
+                        rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...mate2.matePath));
+                    }
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(rId, CCClasses.CCLinearPatternConstraint, name);
+                    if (constraintId != null) {
+                        const firstDirInstanceCountParam = {
+                            value: firstDirInstanceCount,
+                            isExpr: typeof firstDirInstanceCount === 'string',
+                        };
+                        const firstDirDistanceParam = {
+                            value: firstDirDistance,
+                            isExpr: typeof firstDirDistance === 'string',
+                        };
+                        const secondDirInstanceCountParam = secondDirInstanceCount !== undefined
+                            ? {
+                                value: secondDirInstanceCount,
+                                isExpr: typeof secondDirInstanceCount === 'string',
+                            }
+                            : undefined;
+                        const secondDirDistanceParam = secondDirDistance !== undefined
+                            ? {
+                                value: secondDirDistance,
+                                isExpr: typeof secondDirDistance === 'string',
+                            }
+                            : undefined;
+                        await assemblyBuilderAPI.updateLinearPatternConstraints([
+                            {
+                                constrId: constraintId,
+                                instanceId: rInstanceId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: mate1.flip,
+                                    reoriented: mate1.reoriented,
+                                },
+                                firstDirInstanceCount: firstDirInstanceCountParam,
+                                firstDirDistance: firstDirDistanceParam,
+                                mate2: mate2
+                                    ? {
+                                        matePath: rMatePath2,
+                                        wcsId: rWcs2,
+                                        flip: mate2.flip,
+                                        reoriented: mate2.reoriented,
+                                    }
+                                    : undefined,
+                                secondDirInstanceCount: secondDirInstanceCountParam,
+                                secondDirDistance: secondDirDistanceParam,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateLinearPatternConstraints: async (...constraints) => {
+                    var e_11, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_9 = __asyncValues(constraints), constraints_9_1; constraints_9_1 = await constraints_9.next(), !constraints_9_1.done;) {
+                            const constr = constraints_9_1.value;
+                            const [rConstrId, rInstanceId, rWcs1, rWcs2] = await new Promise(res => {
+                                var _a;
+                                return this.resolve(ids => res(ids), constr.constrId, constr.instanceId, constr.mate1.wcsId, (_a = constr.mate2) === null || _a === void 0 ? void 0 : _a.wcsId);
+                            });
+                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            let rMatePath2;
+                            if (constr.mate2) {
+                                rMatePath2 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate2.matePath));
+                            }
+                            const firstDirInstanceCountParam = {
+                                value: constr.firstDirInstanceCount,
+                                isExpr: typeof constr.firstDirInstanceCount === 'string',
+                            };
+                            const firstDirDistanceParam = {
+                                value: constr.firstDirDistance,
+                                isExpr: typeof constr.firstDirDistance === 'string',
+                            };
+                            const secondDirInstanceCountParam = constr.secondDirInstanceCount !== undefined
+                                ? {
+                                    value: constr.secondDirInstanceCount,
+                                    isExpr: typeof constr.secondDirInstanceCount === 'string',
+                                }
+                                : undefined;
+                            const secondDirDistanceParam = constr.secondDirDistance !== undefined
+                                ? {
+                                    value: constr.secondDirDistance,
+                                    isExpr: typeof constr.secondDirDistance === 'string',
+                                }
+                                : undefined;
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                instanceId: rInstanceId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                firstDirInstanceCount: firstDirInstanceCountParam,
+                                firstDirDistance: firstDirDistanceParam,
+                                mate2: constr.mate2
+                                    ? {
+                                        matePath: rMatePath2,
+                                        wcsId: rWcs2,
+                                        flip: constr.mate2.flip,
+                                        reoriented: constr.mate2.reoriented,
+                                    }
+                                    : undefined,
+                                secondDirInstanceCount: secondDirInstanceCountParam,
+                                secondDirDistance: secondDirDistanceParam,
+                            });
+                        }
+                    }
+                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    finally {
+                        try {
+                            if (constraints_9_1 && !constraints_9_1.done && (_a = constraints_9.return)) await _a.call(constraints_9);
+                        }
+                        finally { if (e_11) throw e_11.error; }
+                    }
+                    await assemblyBuilderAPI.updateLinearPatternConstraints(constrToAdd);
+                },
+                createCircularPatternConstraint: async (id, instanceId, mate1, instanceCount, angle, offset, name) => {
+                    const [rId, rInstanceId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), id, instanceId, mate1.wcsId));
+                    const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...mate1.matePath));
+                    const constraintId = await assemblyBuilderAPI.create3DConstraint(rId, CCClasses.CCCircularPatternConstraint, name);
+                    if (constraintId != null) {
+                        const instanceCountParam = {
+                            value: instanceCount,
+                            isExpr: typeof instanceCount === 'string',
+                        };
+                        const angleParam = { value: angle, isExpr: typeof angle === 'string' };
+                        const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
+                        await assemblyBuilderAPI.updateCircularPatternConstraints([
+                            {
+                                constrId: constraintId,
+                                instanceId: rInstanceId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: mate1.flip,
+                                    reoriented: mate1.reoriented,
+                                },
+                                instanceCount: instanceCountParam,
+                                angle: angleParam,
+                                offset: offsetParam,
+                            },
+                        ]);
+                        return constraintId;
+                    }
+                    return null;
+                },
+                updateCircularPatternConstraints: async (...constraints) => {
+                    var e_12, _a;
+                    const constrToAdd = [];
+                    try {
+                        for (var constraints_10 = __asyncValues(constraints), constraints_10_1; constraints_10_1 = await constraints_10.next(), !constraints_10_1.done;) {
+                            const constr = constraints_10_1.value;
+                            const [rConstrId, rInstanceId, rWcs1] = await new Promise(res => this.resolve(ids => res(ids), constr.constrId, constr.instanceId, constr.mate1.wcsId));
+                            const rMatePath1 = await new Promise(res => this.resolve(paths => res(paths), ...constr.mate1.matePath));
+                            const instanceCountParam = {
+                                value: constr.instanceCount,
+                                isExpr: typeof constr.instanceCount === 'string',
+                            };
+                            const angleParam = { value: constr.angle, isExpr: typeof constr.angle === 'string' };
+                            const offsetParam = { value: constr.offset, isExpr: typeof constr.offset === 'string' };
+                            constrToAdd.push({
+                                constrId: rConstrId,
+                                instanceId: rInstanceId,
+                                mate1: {
+                                    matePath: rMatePath1,
+                                    wcsId: rWcs1,
+                                    flip: constr.mate1.flip,
+                                    reoriented: constr.mate1.reoriented,
+                                },
+                                instanceCount: instanceCountParam,
+                                angle: angleParam,
+                                offset: offsetParam,
+                            });
+                        }
+                    }
+                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                    finally {
+                        try {
+                            if (constraints_10_1 && !constraints_10_1.done && (_a = constraints_10.return)) await _a.call(constraints_10);
+                        }
+                        finally { if (e_12) throw e_12.error; }
+                    }
+                    await assemblyBuilderAPI.updateCircularPatternConstraints(constrToAdd);
+                },
+                update3dConstraintValues: async (...constrValues) => {
+                    var e_13, _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_13_1) { e_13 = { error: e_13_1 }; }
+                    finally {
+                        try {
+                            if (constrValues_1_1 && !constrValues_1_1.done && (_a = constrValues_1.return)) await _a.call(constrValues_1);
+                        }
+                        finally { if (e_13) throw e_13.error; }
+                    }
+                    await assemblyBuilderAPI.update3DConstraintValues(constrValueParams);
+                },
+                createBufferGeometry: async (objectId) => {
+                    await this.queue;
+                    this.queue = Promise.resolve(0);
+                    const rObjectId = await objectId;
+                    const cDrawing = getDrawing(drawingId);
+                    const structureTree = cDrawing.structure.tree;
+                    const bufferGeomArray = [];
+                    if (rObjectId != null) {
+                        const rootObj = structureTree[rObjectId];
+                        await createRecursiveBufferGeometry(rootObj, drawingId, bufferGeomArray);
+                        if (bufferGeomArray.length > 0) {
+                            return bufferGeomArray;
+                        }
+                    }
+                    return undefined;
+                },
+                createScene: async (objectId, options) => {
+                    await this.queue;
+                    this.queue = Promise.resolve(0);
+                    const cDrawing = getDrawing(drawingId);
+                    const structureTree = cDrawing.structure.tree;
+                    const rObjectId = objectId ? await objectId : cDrawing.structure.root;
+                    const scene = new Scene();
+                    const result = {
+                        nodes: {},
+                        materials: {},
+                    };
+                    if (rObjectId != null) {
+                        const rootObj = structureTree[rObjectId];
+                        if (rootObj) {
+                            await createRecursiveScene(rootObj, drawingId, scene, result, options);
+                        }
+                        else {
+                            throw new Error('Root object does not exist!');
+                        }
+                    }
+                    return Object.assign({ scene }, result);
+                },
+                createExpressions: (partId, ...members) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const membersToAdd = [];
+                        members.forEach(mem => {
+                            const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen STrings
+                            const dataType = DataType.REAL; // TODO: Aktuell nur Real Werte als Expression
+                            const featureAPIParam = {
+                                value: mem.value,
+                                isExpr: isExpr,
+                            };
+                            membersToAdd.push({ name: mem.name, value: featureAPIParam, dataType });
+                        });
+                        const success = featureAPI.updateExpressions([
+                            { productId: rPartId, toAddMembers: membersToAdd, toModifyMembers: [], toDeleteList: [] },
+                        ]);
+                        return success;
+                    }, partId);
+                },
+                createAssemblyAsTemplate: (name) => {
+                    return this.resolve(async ([]) => {
+                        return await assemblyBuilderAPI.createAssemblyAsTemplate(name);
+                    });
+                },
+                createRootAssembly: (name, options) => {
+                    return this.resolve(async ([]) => {
+                        return await assemblyBuilderAPI.createRootAssembly(name, options);
+                    });
+                },
+                createPart: (name) => {
+                    return this.resolve(async ([]) => {
+                        const partName = name ? name : 'Part';
+                        return await featureAPI.newPart(partName);
+                    });
+                },
+                createPartAsTemplate: (name) => {
+                    return this.resolve(async ([]) => {
+                        const partName = name ? name : 'Part';
+                        return await assemblyBuilderAPI.createPartAsTemplate(partName);
+                    });
+                },
+                createWorkAxis: (partId, type, references, position, direction, local, name) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const wAName = name ? name : 'WorkAxis';
+                        const wAId = await featureAPI.createWorkGeometry(rPartId, CCClasses.CCWorkAxis, wAName);
+                        if (wAId != null) {
+                            const resPosition = resolveVec(position);
+                            const positionParam = {
+                                value: resPosition,
+                                isExpr: typeof resPosition === 'string',
+                            };
+                            const resDirection = resolveVec(direction);
+                            const directionParam = {
+                                value: resDirection,
+                                isExpr: typeof resDirection === 'string',
+                            };
+                            await featureAPI.updateWorkAxis(wAId, type, rReferences, positionParam, directionParam, local);
+                            return wAId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                createWorkCoordSystem: (partId, type, references, offset, rotation, inverted = false, name) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const wCSName = name ? name : 'WorkCoordSystem';
+                        const wCSId = await featureAPI.createWorkGeometry(rPartId, CCClasses.CCWorkCSys, wCSName);
+                        if (wCSId != null) {
+                            const resOffset = resolveVec(offset);
+                            const offsetParam = {
+                                value: resOffset,
+                                isExpr: typeof resOffset === 'string',
+                            };
+                            const resRotation = resolveVec(rotation);
+                            const rotationParam = {
+                                value: resRotation,
+                                isExpr: typeof resRotation === 'string',
+                            };
+                            await featureAPI.updateWorkCSys(wCSId, type, rReferences, offsetParam, rotationParam, inverted ? 1 : 0);
+                            return wCSId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                createWorkPlane: (partId, type, references, offset, angle, position, normal, local, name) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const wPName = name ? name : 'WorkPlane';
+                        const wPId = await featureAPI.createWorkGeometry(rPartId, CCClasses.CCWorkPlane, wPName);
+                        if (wPId != undefined) {
+                            const offsetParam = { value: offset, isExpr: typeof offset === 'string' };
+                            const angleParam = { value: angle, isExpr: typeof angle === 'string' };
+                            const resPosition = resolveVec(position);
+                            const positionParam = {
+                                value: resPosition,
+                                isExpr: typeof resPosition === 'string',
+                            };
+                            const resNormal = resolveVec(normal);
+                            const normalParam = {
+                                value: resNormal,
+                                isExpr: typeof resNormal === 'string',
+                            };
+                            await featureAPI.updateWorkPlane(wPId, type, rReferences, offsetParam, angleParam, positionParam, normalParam, local);
+                            return wPId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                createWorkPoint: (partId, type, references, position, local, name) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const wPTName = name ? name : 'WorkPoint';
+                        const wPTId = await featureAPI.createWorkGeometry(rPartId, CCClasses.CCWorkPoint, wPTName);
+                        if (wPTId != undefined) {
+                            const resPosition = resolveVec(position);
+                            const positionParam = {
+                                value: resPosition,
+                                isExpr: typeof resPosition === 'string',
+                            };
+                            await featureAPI.updateWorkPoint(wPTId, type, rReferences, positionParam, local);
+                            return wPTId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                fillet: (partId, references, radius) => {
+                    return this.resolve(async ([rPartId, rReferences]) => {
+                        const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
+                        const filletId = await featureAPI.createFeature(rPartId, CCClasses.CCConstantRadiusFillet, 'Fillet');
+                        if (filletId != null) {
+                            await featureAPI.updateFillet(filletId, rReferences, radiusParam);
+                            return filletId;
+                        }
+                        return null;
+                    }, partId, references);
+                },
+                selectGeometry: (types, count) => {
+                    const drId = this.drawingId;
+                    return this.resolve(async ([]) => {
+                        const filter = (scope, data) => scope === BuerliScope && types.some(type => type === data);
+                        // Check count param. If not set use by default 1, else check if not < 1
+                        const lCount = count ? (count < 1 ? 1 : count) : 1;
+                        const selections = (await waitForSelect(lCount, filter, (resolveSelection, items, diff) => {
+                            if (items.length > lCount - 1) {
+                                resolveSelection(items);
+                            }
+                        }));
+                        const interactionInfos = [];
+                        for (const selection of selections) {
+                            // Get matching points from selected geometry and add to userData. TODO: Only if in part mode useful?
+                            const points = await geometryAPI.getPointsByGeometries([selection.data.graphicId]);
+                            const matrix = getDrawing(drId).api.structure.calculateGlobalTransformation(selection.data.productId);
+                            const clone = selection.data.geometry.clone().applyMatrix4(matrix);
+                            // TODO: Should the transform code be moved to something else than Measure? It's helpful for more cases than just measuring.
+                            const transformedData = Measure.transform([selection.data], drId)[0];
+                            const interactionInfo = createInfo({
+                                objectId: selection.data.container.ownerId,
+                                prodRefId: selection.data.productId,
+                                containerId: selection.data.container.id,
+                                graphicId: selection.data.graphicId,
+                                // objectPath: ?,  TODO: Add path to the root in expanded tree, as soon as available
+                                userData: Object.assign(Object.assign({}, transformedData), { geometry: clone, matchingPoints: points }),
+                            });
+                            interactionInfos.push(interactionInfo);
+                        }
+                        return interactionInfos;
+                    });
+                },
+                findGeometry: (partId, type, positions) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const geoms = await geometryAPI.findGeometriesByPoints(rPartId, type, positions.map(pos => pos.map(p => resolveVec(p))));
+                        return geoms;
+                    }, partId);
+                },
+                getAssemblyTemplate: (asmName) => {
+                    return this.resolve(async ([]) => {
+                        const asmIds = asmUtils.getAssemblyTemplate(drawingId, asmName);
+                        if (asmIds != undefined) {
+                            return Array.isArray(asmIds) ? asmIds : [asmIds];
+                        }
+                        return null;
+                    });
+                },
+                getInstance: (id, instanceName) => {
+                    return this.resolve(async ([rId]) => {
+                        const instances = asmUtils.getInstance(drawingId, rId, instanceName);
+                        if (instances != undefined) {
+                            return Array.isArray(instances) ? instances : [instances];
+                        }
+                        return null;
+                    }, id);
+                },
+                findInstance: (options) => {
+                    return this.resolve(async () => {
+                        const instance = baseUtils.findObject(drawingId, {
+                            ident: options.instanceIdent,
+                            name: options.instanceName,
+                        });
+                        if (!instance) {
+                            return null;
+                        }
+                        const clazz = getDrawing(drawingId).structure.tree[instance].class;
+                        if (!baseUtils.isA(clazz, CCClasses.IProductReference)) {
+                            return null;
+                        }
+                        else {
+                            return instance;
+                        }
+                    });
+                },
+                getProductsOfInstances: (instanceIds) => {
+                    return this.resolve(async ([rInstanceIds]) => {
+                        const drawing = getDrawing(drawingId);
+                        const tree = drawing.structure.tree;
+                        const products = [];
+                        for (const rInstanceId of rInstanceIds) {
+                            const product = asmUtils.findProduct(rInstanceId, tree);
+                            products.push(product);
+                        }
+                        return products;
+                    }, instanceIds);
+                },
+                setCurrentInstance: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        await assemblyBuilderAPI.setCurrentInstance(rId);
+                    }, id);
+                },
+                getCurrentInstance: () => {
+                    return this.resolve(async () => {
+                        const drw = getDrawing(drawingId);
+                        return drw.structure.currentInstance;
+                    });
+                },
+                getTransformation: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        const coordSys = asmUtils.getTransformation(drawingId, rId);
+                        if (coordSys != undefined) {
+                            return coordSys;
+                        }
+                        return null;
+                    }, id);
+                },
+                setCurrentProduct: (productId) => {
+                    return this.resolve(async ([rProductId]) => {
+                        await baseModelerAPI.setCurrentProduct(rProductId);
+                    }, productId);
+                },
+                getCurrentProduct: () => {
+                    return this.resolve(async () => {
+                        const drw = getDrawing(drawingId);
+                        return drw.structure.currentProduct;
+                    });
+                },
+                getPartTemplate: (partName) => {
+                    return this.resolve(async ([]) => {
+                        const partIds = asmUtils.getPartTemplate(drawingId, partName);
+                        if (partIds != undefined) {
+                            return Array.isArray(partIds) ? partIds : [partIds];
+                        }
+                        return null;
+                    });
+                },
+                getWorkCoordSystem: (id, wcsName) => {
+                    return this.resolve(async ([rId]) => {
+                        console.warn('Warning: getWorkCoordSystem() is deprecated, use getWorkGeometry() instead, getWorkCoordSystem() will be removed in a future release.');
+                        const wcsIds = asmUtils.getWorkCoordSystem(drawingId, rId, wcsName);
+                        if (wcsIds != undefined) {
+                            return Array.isArray(wcsIds) ? wcsIds : [wcsIds];
+                        }
+                        return null;
+                    }, id);
+                },
+                getSketchRegion: (id, sketchRegionName) => {
+                    return this.resolve(async ([rId]) => {
+                        const sRIds = partUtils.getSketchRegion(drawingId, rId, sketchRegionName);
+                        if (sRIds != undefined) {
+                            return Array.isArray(sRIds) ? sRIds : [sRIds];
+                        }
+                        return null;
+                    }, id);
+                },
+                getSketch: (id, sketchName) => {
+                    return this.resolve(async ([rId]) => {
+                        const sIds = partUtils.getSketch(drawingId, rId, sketchName);
+                        if (sIds != undefined) {
+                            return Array.isArray(sIds) ? sIds : [sIds];
+                        }
+                        return null;
+                    }, id);
+                },
+                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]) => {
+                        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: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getFastenedConstraint(drawingId, rId, 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,
+                                xRotation: constraint.xRotation.value,
+                                yRotation: constraint.yRotation.value,
+                                zRotation: constraint.zRotation.value,
+                            };
+                        }
+                        return null;
+                    }, id);
+                },
+                getFastenedOriginConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getFastenedOriginConstraint(drawingId, rId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                xOffset: constraint.xOffset.value,
+                                yOffset: constraint.yOffset.value,
+                                zOffset: constraint.zOffset.value,
+                                xRotation: constraint.xRotation.value,
+                                yRotation: constraint.yRotation.value,
+                                zRotation: constraint.zRotation.value,
+                            };
+                        }
+                        return null;
+                    }, id);
+                },
+                getRevoluteConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getRevoluteConstraint(drawingId, rId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                mate2: constraint.mate2,
+                                zOffset: constraint.zOffset.value,
+                                zRotationLimits: constraint.zRotationLimits,
+                            };
+                        }
+                        return null;
+                    }, id);
+                },
+                getSliderConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getSliderConstraint(drawingId, rId, 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;
+                    }, id);
+                },
+                getPlanarConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getPlanarConstraint(drawingId, rId, 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;
+                    }, id);
+                },
+                getParallelConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getParallelConstraint(drawingId, rId, 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;
+                    }, id);
+                },
+                getCylindricalConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getCylindricalConstraint(drawingId, rId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                mate1: constraint.mate1,
+                                mate2: constraint.mate2,
+                                zOffsetLimits: constraint.zOffsetLimits,
+                                zRotationLimits: constraint.zRotationLimits,
+                            };
+                        }
+                        return null;
+                    }, id);
+                },
+                getGroupConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getGroupConstraint(drawingId, rId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                instanceIds: constraint.instanceIds,
+                            };
+                        }
+                        return null;
+                    }, id);
+                },
+                getLinearPatternConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        var _a, _b;
+                        const constraint = asmUtils.getLinearPatternConstraint(drawingId, rId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                instanceId: constraint.instanceId,
+                                mate1: constraint.mate1,
+                                firstDirInstanceCount: constraint.firstDirInstanceCount.value,
+                                firstDirDistance: constraint.firstDirDistance.value,
+                                mate2: constraint.mate2,
+                                secondDirInstanceCount: (_a = constraint === null || constraint === void 0 ? void 0 : constraint.secondDirInstanceCount) === null || _a === void 0 ? void 0 : _a.value,
+                                secondDirDistance: (_b = constraint === null || constraint === void 0 ? void 0 : constraint.secondDirDistance) === null || _b === void 0 ? void 0 : _b.value,
+                            };
+                        }
+                        return null;
+                    }, id);
+                },
+                getCircularPatternConstraint: (id, constrName) => {
+                    return this.resolve(async ([rId]) => {
+                        const constraint = asmUtils.getCircularPatternConstraint(drawingId, rId, constrName);
+                        if (constraint != undefined) {
+                            return {
+                                constrId: constraint.constrId,
+                                instanceId: constraint.instanceId,
+                                mate1: constraint.mate1,
+                                instanceCount: constraint.instanceCount.value,
+                                angle: constraint.angle.value,
+                                offset: constraint.offset.value,
+                            };
+                        }
+                        return null;
+                    }, id);
+                },
+                getFeatureByName: (partId, featureName) => {
+                    return this.resolve(async ([rProductId]) => {
+                        const feature = await featureAPI.getFeatureByName(rProductId, featureName);
+                        if (feature !== null) {
+                            return feature;
+                        }
+                        return null;
+                    }, partId);
+                },
+                getGeometryInformation: (id) => {
+                    return this.resolve(async ([rId]) => {
+                        const values = await baseModelerAPI.getGeometryInformation(rId);
+                        if (values !== null) {
+                            return { centerOfGravity: values[0], volume: values[1] };
+                        }
+                        return null;
+                    }, id);
+                },
+                removeInstances: async (...instances) => {
+                    var e_14, _a;
+                    const instancesToRemove = [];
+                    try {
+                        for (var instances_2 = __asyncValues(instances), instances_2_1; instances_2_1 = await instances_2.next(), !instances_2_1.done;) {
+                            const instance = instances_2_1.value;
+                            const [rInstanceId] = await new Promise(res => this.resolve(id => res(id), instance.id));
+                            let instanceId = rInstanceId;
+                            if (typeof rInstanceId === 'string') {
+                                instanceId = baseUtils.findObject(drawingId, {
+                                    ident: rInstanceId,
+                                    name: rInstanceId,
+                                });
+                                if (!instanceId) {
+                                    throw 'The instance to remove given by name or ident "' + rInstanceId + '" does not exist.';
+                                }
+                                const clazz = getDrawing(drawingId).structure.tree[instanceId].class;
+                                if (!baseUtils.isA(clazz, CCClasses.IProductReference)) {
+                                    throw ('The instance to remove given by name or ident "' +
+                                        rInstanceId +
+                                        '" is of the wrong type "' +
+                                        clazz +
+                                        '". Make sure the object is an instance.');
+                                }
+                            }
+                            const instanceParam = { id: instanceId };
+                            instancesToRemove.push(instanceParam);
+                        }
+                    }
+                    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                    finally {
+                        try {
+                            if (instances_2_1 && !instances_2_1.done && (_a = instances_2.return)) await _a.call(instances_2);
+                        }
+                        finally { if (e_14) throw e_14.error; }
+                    }
+                    return assemblyBuilderAPI.removeInstances(instancesToRemove);
+                },
+                importFeature: (partId, content, format, name) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const featureName = name ? name : 'Import';
+                        const importFeatureId = await featureAPI.createFeature(rPartId, CCClasses.CCImport, featureName);
+                        if (importFeatureId !== null) {
+                            const solids = await featureAPI.updateImport(importFeatureId, content, format.toUpperCase(), featureName);
+                            if (solids !== null) {
+                                return importFeatureId;
+                            }
+                        }
+                        return null;
+                    }, partId);
+                },
+                loadSketch: (partId, stream, planeId, name) => {
+                    return this.resolve(async ([rPartId, rPlaneId]) => {
+                        const sketch = await sketcherAPI.createSketch(rPartId);
+                        if (sketch) {
+                            await featureAPI.closeFeature(sketch);
+                            const tree = getDrawing(drawingId).structure.tree;
+                            const plane = tree[rPlaneId];
+                            if (plane && baseUtils.isA(plane.class, CCClasses.CCWorkPlane)) {
+                                await sketcherAPI.setWorkPlane(sketch, rPlaneId);
+                            }
+                            else {
+                                await sketcherAPI.createAndSetWorkPlane(sketch, rPlaneId);
+                            }
+                            await sketcherAPI.loadSketch(rPartId, sketch, stream, name);
+                            return sketch;
+                        }
+                    }, partId, planeId);
+                },
+                copySketch: (partId, sketchId, planeId) => {
+                    return this.resolve(async ([rPartId, rPlaneId, rSketchId]) => {
+                        const sketch = await sketcherAPI.createSketch(rPartId);
+                        if (sketch) {
+                            await featureAPI.closeFeature(sketch);
+                            const tree = getDrawing(drawingId).structure.tree;
+                            const plane = tree[rPlaneId];
+                            if (plane && baseUtils.isA(plane.class, CCClasses.CCWorkPlane)) {
+                                await sketcherAPI.setWorkPlane(sketch, rPlaneId);
+                            }
+                            else {
+                                await sketcherAPI.createAndSetWorkPlane(sketch, rPlaneId);
+                            }
+                            await sketcherAPI.copySketch(sketch, rSketchId);
+                            return sketch;
+                        }
+                    }, partId, planeId, sketchId);
+                },
+                placeSketch: (sketchId, planeId, invertPlane, axisId, isXAxis, invertAxis, originId) => {
+                    return this.resolve(async ([rSketchId, rPlaneId, rAxisId, rOriginId]) => {
+                        await sketcherAPI.setSketchRefs(rSketchId, rPlaneId, invertPlane, rAxisId, isXAxis, invertAxis, rOriginId);
+                    }, sketchId, planeId, axisId, originId);
+                },
+                transformInstances: async (...instances) => {
+                    var e_15, _a;
+                    const instancesToTransform = [];
+                    try {
+                        for (var instances_3 = __asyncValues(instances), instances_3_1; instances_3_1 = await instances_3.next(), !instances_3_1.done;) {
+                            const instance = instances_3_1.value;
+                            const [rInstanceId] = await new Promise(res => this.resolve(id => res(id), instance.id));
+                            let instanceId = rInstanceId;
+                            if (typeof rInstanceId === 'string') {
+                                instanceId = baseUtils.findObject(drawingId, {
+                                    ident: rInstanceId,
+                                    name: rInstanceId,
+                                });
+                                if (!instanceId) {
+                                    throw 'The instance to transform given by name or ident "' + rInstanceId + '" does not exist.';
+                                }
+                                const clazz = getDrawing(drawingId).structure.tree[instanceId].class;
+                                if (!baseUtils.isA(clazz, CCClasses.IProductReference)) {
+                                    throw ('The instance to transform given by name or ident "' +
+                                        rInstanceId +
+                                        '" is of the wrong type "' +
+                                        clazz +
+                                        '". Make sure the object is an instance.');
+                                }
+                            }
+                            const instanceParam = {
+                                id: instanceId,
+                                transformation: instance.transformation,
+                                options: { isLocal: true }, // in non-interactive mode, the transformation is local to the owner
+                            };
+                            instancesToTransform.push(instanceParam);
+                        }
+                    }
+                    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                    finally {
+                        try {
+                            if (instances_3_1 && !instances_3_1.done && (_a = instances_3.return)) await _a.call(instances_3);
+                        }
+                        finally { if (e_15) throw e_15.error; }
+                    }
+                    return assemblyBuilderAPI.transformInstances(instancesToTransform);
+                },
+                translate: (partId, operations, references, inverted, distance) => {
+                    return this.resolve(async ([rPartId, rOperations, ...rReferences]) => {
+                        const translationId = await featureAPI.createFeature(rPartId, CCClasses.CCTranslation, 'Translate');
+                        if (translationId !== null) {
+                            const cDrawing = await getDrawing(drawingId);
+                            const entArray = [];
+                            for (const rOperation of rOperations) {
+                                const entities = cDrawing.structure.tree[(await rOperation)].children;
+                                if (entities != undefined) {
+                                    entArray.push(entities[0]);
+                                }
+                            }
+                            const dist = { value: distance, isExpr: typeof distance === 'string' };
+                            await featureAPI.updateTransformation(translationId, entArray, rReferences, inverted, dist);
+                            return translationId;
+                        }
+                        return null;
+                    }, partId, operations, ...references);
+                },
+                // TODO: Remove this method. Is it necessary?
+                updateTranslate: (translationId, distance) => {
+                    return this.resolve(async ([rTranslationId]) => {
+                        const cDrawing = await getDrawing(drawingId);
+                        const members = cDrawing.structure.tree[rTranslationId].members;
+                        if (members !== null && members !== undefined) {
+                            const entArray = members['bodiesToTransform'].members.map(m => m.value);
+                            const references = members['references'].members.map(m => m.value);
+                            const inverted = members['inverted'].value;
+                            const dist = distance !== null ? distance : members['translationDistance'].value;
+                            const distParam = { value: dist, isExpr: typeof distance === 'string' };
+                            await featureAPI.openFeature(rTranslationId);
+                            await featureAPI.updateTransformation(rTranslationId, entArray, references, inverted, distParam);
+                            await featureAPI.closeFeature(rTranslationId);
+                        }
+                    }, translationId);
+                },
+                save: (type) => {
+                    return baseModelerAPI.save(type);
+                },
+                saveToUrl: (url, filetype) => {
+                    return baseModelerAPI.saveToUrl(url, filetype);
+                },
+                load: (content, type, options) => {
+                    return baseModelerAPI.load(content, type, '', options);
+                },
+                loadFromUrl: (url, filetype, options) => {
+                    return baseModelerAPI.loadFromUrl(url, filetype, true, options);
+                },
+                loadProduct: (content, type, options) => {
+                    return assemblyBuilderAPI.loadProduct(content, type, options);
+                },
+                loadProductFromUrl: (url, filetype, options) => {
+                    return assemblyBuilderAPI.loadProductFromUrl(url, filetype, options);
+                },
+                pick: (partId, type, points) => {
+                    return this.resolve(async ([rPartId]) => {
+                        console.warn('Warning: pick() is deprecated, use findGeometry() instead, pick() will be removed in a future release.');
+                        const refs = await featureAPI.pick(rPartId, type, points.map(p => resolveVec(p)));
+                        if (refs != undefined) {
+                            return Array.isArray(refs) ? refs : [refs];
+                        }
+                        return null;
+                    }, partId);
+                },
+                setExpressions: async (...expressions) => {
+                    var e_16, _a;
+                    const expressionsToSet = [];
+                    try {
+                        for (var expressions_1 = __asyncValues(expressions), expressions_1_1; expressions_1_1 = await expressions_1.next(), !expressions_1_1.done;) {
+                            const expr = expressions_1_1.value;
+                            const [rPartId] = await new Promise(res => this.resolve(id => res(id), expr.partId));
+                            const membersToModify = [];
+                            expr.members.forEach((mem) => {
+                                const isExpr = typeof mem.value === 'string'; // TODO Expression unterscheiden von normalen Strings
+                                const featureAPIParam = {
+                                    value: mem.value,
+                                    isExpr,
+                                };
+                                membersToModify.push({ name: mem.name, value: featureAPIParam });
+                            });
+                            // Looking for the partId given by an identifier or name
+                            let part = rPartId;
+                            if (typeof part === 'string') {
+                                const foundPart = baseUtils.findObject(drawingId, { ident: part, name: part });
+                                if (!foundPart) {
+                                    throw 'No part found to set expressions on for given name or ident: ' + part;
+                                }
+                                const clazz = getDrawing(drawingId).structure.tree[foundPart].class;
+                                if (!baseUtils.isA(clazz, CCClasses.CCPart)) {
+                                    throw ('The part to set expressions on given by name or ident "' +
+                                        part +
+                                        '" is of the wrong type "' +
+                                        clazz +
+                                        '". Make sure the object is a part.');
+                                }
+                                else {
+                                    part = foundPart;
+                                }
+                            }
+                            expressionsToSet.push({
+                                productId: part,
+                                toAddMembers: [],
+                                toModifyMembers: membersToModify,
+                                toDeleteList: [],
+                            });
+                        }
+                    }
+                    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+                    finally {
+                        try {
+                            if (expressions_1_1 && !expressions_1_1.done && (_a = expressions_1.return)) await _a.call(expressions_1);
+                        }
+                        finally { if (e_16) throw e_16.error; }
+                    }
+                    const success = await featureAPI.updateExpressions(expressionsToSet);
+                    return success;
+                },
+                renameExpressions: (partId, members) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const success = featureAPI.updateExpressions([
+                            { productId: rPartId, toAddMembers: [], toModifyMembers: [], toRenameMembers: members, toDeleteList: [] },
+                        ]);
+                        return success;
+                    }, partId);
+                },
+                deleteExpressions: (partId, members) => {
+                    return this.resolve(async ([rPartId]) => {
+                        const success = featureAPI.updateExpressions([
+                            { productId: rPartId, toAddMembers: [], toModifyMembers: [], toDeleteList: members },
+                        ]);
+                        return success;
+                    }, partId);
+                },
+                sphere: (partId, references, radius) => {
+                    return this.resolve(async ([rPartId, ...rReferences]) => {
+                        const sphereId = await featureAPI.createFeature(rPartId, CCClasses.CCSphere, 'Sphere');
+                        if (sphereId != null) {
+                            const radiusParam = { value: radius, isExpr: typeof radius === 'string' };
+                            await featureAPI.updateSphere(sphereId, rReferences, radiusParam);
+                            return sphereId;
+                        }
+                        return null;
+                    }, partId, ...references);
+                },
+                mirror: async (partId, operations, references) => {
+                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
+                    const rOperations = await new Promise(res => this.resolve(ids => res(ids), ...operations));
+                    const rReferences = await new Promise(res => this.resolve(paths => res(paths), ...references));
+                    const cDrawing = getDrawing(drawingId);
+                    const entArray = [];
+                    for (const rOperation of rOperations) {
+                        const entities = cDrawing.structure.tree[rOperation].children;
+                        if (entities != undefined) {
+                            entArray.push(entities[0]);
+                        }
+                    }
+                    const mirrorId = await featureAPI.createFeature(rPartId, CCClasses.CCMirror, 'Mirror');
+                    if (mirrorId != null) {
+                        await featureAPI.updateMirror(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(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(toRemoveOps);
+                    }
+                },
+                getMatePath: async (refId) => {
+                    return this.resolve(async ([rRefId]) => {
+                        return asmUtils.getMatePath(drawingId, rRefId);
+                    }, refId);
+                },
+                slice: async (partId, operations, reference, sideFlag) => {
+                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
+                    const rOperations = await new Promise(res => this.resolve(ids => res(ids), ...operations));
+                    const [rReference] = await new Promise(res => this.resolve(paths => res(paths), reference));
+                    const cDrawing = getDrawing(drawingId);
+                    const entArray = [];
+                    for (const rOperation of rOperations) {
+                        const entities = cDrawing.structure.tree[rOperation].children;
+                        if (entities != undefined && entities.length > 0) {
+                            entArray.push(entities[0]); // use first entity of operation
+                        }
+                    }
+                    const sliceId = await featureAPI.createFeature(rPartId, CCClasses.CCSlice, 'Slice');
+                    if (sliceId != null) {
+                        await featureAPI.openFeature(sliceId);
+                        if (entArray.length > 0) {
+                            await featureAPI.updateSlice(sliceId, entArray, rReference, sideFlag ? 1 : 0);
+                            await featureAPI.closeFeature(sliceId);
+                            return sliceId;
+                        }
+                        await featureAPI.closeFeature(sliceId);
+                        await baseModelerAPI.deleteObjects([sliceId]);
+                    }
+                    return null;
+                },
+                sliceBySheet: async (partId, operationToSlice, operationOfSheet, sideFlag) => {
+                    const [rPartId] = await new Promise(res => this.resolve(ids => res(ids), partId));
+                    const [rOperationToSlice] = await new Promise(res => this.resolve(ids => res(ids), operationToSlice));
+                    const [rOperationOfSheet] = await new Promise(res => this.resolve(ids => res(ids), operationOfSheet));
+                    const entityToSlice = getDrawing(drawingId).structure.tree[rOperationToSlice].children;
+                    const entityOfSheet = getDrawing(drawingId).structure.tree[rOperationOfSheet].children;
+                    const sliceBySheetId = await featureAPI.createFeature(rPartId, CCClasses.CCSliceBySheet, 'SliceBySheet');
+                    if (sliceBySheetId != null) {
+                        await featureAPI.openFeature(sliceBySheetId);
+                        if (entityToSlice && entityToSlice.length > 0 && entityOfSheet && entityOfSheet.length > 0) {
+                            await featureAPI.updateSliceBySheet(sliceBySheetId, entityToSlice[0], entityOfSheet[0], sideFlag ? 1 : 0);
+                            await featureAPI.closeFeature(sliceBySheetId);
+                            return sliceBySheetId;
+                        }
+                        await featureAPI.closeFeature(sliceBySheetId);
+                        await baseModelerAPI.deleteObjects([sliceBySheetId]);
+                    }
+                    return null;
+                },
+                twist: async (param) => {
+                    return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
+                        const twist = await featureAPI.createFeature(rPartId, CCClasses.CCTwist, 'Twist');
+                        if (twist) {
+                            const resSketchOrRegionIds = Array.isArray(rSketchOrRegionIds)
+                                ? rSketchOrRegionIds
+                                : [rSketchOrRegionIds];
+                            if (resSketchOrRegionIds && resSketchOrRegionIds.length > 0) {
+                                const limit1Param = {
+                                    value: param.limit1,
+                                    isExpr: typeof param.limit1 === 'string',
+                                };
+                                const limit2Param = {
+                                    value: param.limit2,
+                                    isExpr: typeof param.limit2 === 'string',
+                                };
+                                const twistAngleParam = {
+                                    value: param.twistAngle,
+                                    isExpr: typeof param.twistAngle === 'string',
+                                };
+                                if (!param.direction) {
+                                    param.direction = { x: 0, y: 0, z: 1 };
+                                }
+                                if (!param.twistCenter) {
+                                    param.twistCenter = { x: 0, y: 0, z: 0 };
+                                }
+                                const resDirection = resolveVec(param.direction);
+                                const directionParam = {
+                                    value: resDirection,
+                                    isExpr: typeof resDirection === 'string',
+                                };
+                                const resTwistCenter = resolveVec(param.twistCenter);
+                                const twistCenterParam = {
+                                    value: resTwistCenter,
+                                    isExpr: typeof resTwistCenter === 'string',
+                                };
+                                await featureAPI.updateTwist(twist, resSketchOrRegionIds, param.type, limit1Param, limit2Param, directionParam, twistAngleParam, twistCenterParam, param.capEnds);
+                                return twist;
+                            }
+                        }
+                    }, param.partId, param.sketchOrRegionIds);
+                },
+            };
+            callback(publicApi);
+            resolve(drawingId);
+        });
+        return () => promise.then(drawingId => api.getState().api.removeDrawing(drawingId));
+    }
+    destroy() {
+        this.drawingId && api.getState().api.removeDrawing(this.drawingId);
+    }
+}
+export class history extends History {
+    constructor() {
+        super();
+        console.warn("Warning: 'history' is deprecated, use 'History' instead, 'history' will be removed in a future release.");
+    }
+}