@buerli.io/headless 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @buerli.io/headless
 
+## 0.13.0
+
+### Minor Changes
+
+- - Add new API method `twist()` to create twist feature.
+  - Add new API method `getSketch()`to be able to get a sketch by its name from a part or instance.
+  - Extended input parameter of methods `extrusion()` and `revolve()`, to be able to use sketch curves,
+    sketch regions and composite curves directly, beside sketches which were already possible as input.
+
+### Patch Changes
+
+- Updated dependencies
+- Updated dependencies
+- Updated dependencies
+  - @buerli.io/classcad@0.13.0
+
 ## 0.12.0
 
 ### Patch Changes

package/build/cjs/history.js

@@ -474,8 +474,10 @@ class History {
                     return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
                         const extrusion = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCExtrusion, 'Extrusion');
                         if (extrusion) {
-                            const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
-                            if (sketchLines) {
+                            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 = {
@@ -487,7 +489,7 @@ class History {
                                     value: resDirection,
                                     isExpr: typeof resDirection === 'string',
                                 };
-                                await featureAPI.updateExtrusion(drawingId, extrusion, sketchLines, type, limit1Param, limit2Param, taperAngleParam, directionParam, capEnds);
+                                await featureAPI.updateExtrusion(drawingId, extrusion, resSketchOrRegionIds, type, limit1Param, limit2Param, taperAngleParam, directionParam, capEnds);
                                 return extrusion;
                             }
                         }
@@ -497,11 +499,13 @@ class History {
                     return this.resolve(async ([rPartId, rSketchOrRegionIds, ...rAxisIds]) => {
                         const revolve = await featureAPI.createFeature(drawingId, rPartId, classcad_1.CCClasses.CCRevolve, 'Revolve');
                         if (revolve) {
-                            const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
-                            if (sketchLines) {
+                            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(drawingId, revolve, sketchLines, rAxisIds, angle1Param, angle2Param, inverted);
+                                await featureAPI.updateRevolve(drawingId, revolve, resSketchOrRegionIds, rAxisIds, angle1Param, angle2Param, inverted);
                                 return revolve;
                             }
                         }
@@ -1085,8 +1089,239 @@ class History {
                     }
                     await assemblyBuilderAPI.updateParallelConstraints(drawingId, constrToAdd);
                 },
-                update3dConstraintValues: async (...constrValues) => {
+                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(drawingId, rId, classcad_1.CCClasses.CCGroupConstraint, name);
+                    if (constraintId != null) {
+                        await assemblyBuilderAPI.updateGroupConstraints(drawingId, [
+                            {
+                                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(drawingId, 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(drawingId, rId, classcad_1.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(drawingId, [
+                            {
+                                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(drawingId, 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(drawingId, rId, classcad_1.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(drawingId, [
+                            {
+                                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(drawingId, 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;) {
@@ -1099,12 +1334,12 @@ class History {
                             });
                         }
                     }
-                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                    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_10) throw e_10.error; }
+                        finally { if (e_13) throw e_13.error; }
                     }
                     await assemblyBuilderAPI.update3DConstraintValues(drawingId, constrValueParams);
                 },
@@ -1423,6 +1658,15 @@ class History {
                         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);
@@ -1559,6 +1803,52 @@ class History {
                         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]) => {
+                        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: constraint.secondDirInstanceCount.value,
+                                secondDirDistance: constraint.secondDirDistance.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(drawingId, rProductId, featureName);
@@ -1578,7 +1868,7 @@ class History {
                     }, id);
                 },
                 removeInstances: async (...instances) => {
-                    var e_11, _a;
+                    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;) {
@@ -1606,12 +1896,12 @@ class History {
                             instancesToRemove.push(instanceParam);
                         }
                     }
-                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    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_11) throw e_11.error; }
+                        finally { if (e_14) throw e_14.error; }
                     }
                     return assemblyBuilderAPI.removeInstances(drawingId, instancesToRemove);
                 },
@@ -1670,7 +1960,7 @@ class History {
                     }, sketchId, planeId, axisId, originId);
                 },
                 transformInstances: async (...instances) => {
-                    var e_12, _a;
+                    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;) {
@@ -1702,12 +1992,12 @@ class History {
                             instancesToTransform.push(instanceParam);
                         }
                     }
-                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                    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_12) throw e_12.error; }
+                        finally { if (e_15) throw e_15.error; }
                     }
                     return assemblyBuilderAPI.transformInstances(drawingId, instancesToTransform);
                 },
@@ -1776,7 +2066,7 @@ class History {
                     }, partId);
                 },
                 setExpressions: async (...expressions) => {
-                    var e_13, _a;
+                    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;) {
@@ -1818,12 +2108,12 @@ class History {
                             });
                         }
                     }
-                    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                    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_13) throw e_13.error; }
+                        finally { if (e_16) throw e_16.error; }
                     }
                     const success = await featureAPI.updateExpressions(drawingId, expressionsToSet);
                     return success;
@@ -1944,6 +2234,48 @@ class History {
                     }
                     return null;
                 },
+                twist: async (param) => {
+                    return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
+                        const twist = await featureAPI.createFeature(drawingId, rPartId, classcad_1.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(drawingId, twist, resSketchOrRegionIds, param.type, limit1Param, limit2Param, directionParam, twistAngleParam, twistCenterParam, param.capEnds);
+                                return twist;
+                            }
+                        }
+                    }, param.partId, param.sketchOrRegionIds);
+                },
             };
             callback(publicApi);
             resolve(drawingId);

package/build/cjs/solid.js

@@ -14,6 +14,7 @@ const core_1 = require("@buerli.io/core");
 const three_1 = require("three");
 const three_stdlib_1 = require("three-stdlib");
 const meshes_1 = require("./utils/meshes");
+const isShape = (entity) => entity && entity.type === 'Shape';
 const solidAPI = classcad_1.ccAPI.solid;
 const toCCVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
 const toCCNbrVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
@@ -336,7 +337,7 @@ class Solid {
                 },
                 extrude: (height, region) => {
                     return this.resolve(async () => {
-                        if (region instanceof three_1.Shape) {
+                        if (isShape(region)) {
                             const curveArray = makeCCData(region.curves);
                             return solidAPI.createExtrudeRegion(drawingId, makeNbrVec(height), curveArray);
                         }
@@ -402,7 +403,7 @@ class Solid {
                 },
                 revolve: (position, direction, angle, region) => {
                     return this.resolve(async () => {
-                        if (region instanceof three_1.Shape) {
+                        if (isShape(region)) {
                             const curveArray = makeCCData(region.curves);
                             return solidAPI.createRevolveRegion(drawingId, makeNbrVec(position), makeNbrVec(direction), angle, curveArray);
                         }

package/build/esm/history.js

@@ -471,8 +471,10 @@ export class History {
                     return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
                         const extrusion = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCExtrusion, 'Extrusion');
                         if (extrusion) {
-                            const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
-                            if (sketchLines) {
+                            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 = {
@@ -484,7 +486,7 @@ export class History {
                                     value: resDirection,
                                     isExpr: typeof resDirection === 'string',
                                 };
-                                await featureAPI.updateExtrusion(drawingId, extrusion, sketchLines, type, limit1Param, limit2Param, taperAngleParam, directionParam, capEnds);
+                                await featureAPI.updateExtrusion(drawingId, extrusion, resSketchOrRegionIds, type, limit1Param, limit2Param, taperAngleParam, directionParam, capEnds);
                                 return extrusion;
                             }
                         }
@@ -494,11 +496,13 @@ export class History {
                     return this.resolve(async ([rPartId, rSketchOrRegionIds, ...rAxisIds]) => {
                         const revolve = await featureAPI.createFeature(drawingId, rPartId, CCClasses.CCRevolve, 'Revolve');
                         if (revolve) {
-                            const sketchLines = partUtils.getSketchlines(drawingId, rSketchOrRegionIds);
-                            if (sketchLines) {
+                            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(drawingId, revolve, sketchLines, rAxisIds, angle1Param, angle2Param, inverted);
+                                await featureAPI.updateRevolve(drawingId, revolve, resSketchOrRegionIds, rAxisIds, angle1Param, angle2Param, inverted);
                                 return revolve;
                             }
                         }
@@ -1082,8 +1086,239 @@ export class History {
                     }
                     await assemblyBuilderAPI.updateParallelConstraints(drawingId, constrToAdd);
                 },
-                update3dConstraintValues: async (...constrValues) => {
+                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(drawingId, rId, CCClasses.CCGroupConstraint, name);
+                    if (constraintId != null) {
+                        await assemblyBuilderAPI.updateGroupConstraints(drawingId, [
+                            {
+                                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(drawingId, 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(drawingId, 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(drawingId, [
+                            {
+                                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(drawingId, 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(drawingId, 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(drawingId, [
+                            {
+                                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(drawingId, 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;) {
@@ -1096,12 +1331,12 @@ export class History {
                             });
                         }
                     }
-                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                    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_10) throw e_10.error; }
+                        finally { if (e_13) throw e_13.error; }
                     }
                     await assemblyBuilderAPI.update3DConstraintValues(drawingId, constrValueParams);
                 },
@@ -1420,6 +1655,15 @@ export class History {
                         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);
@@ -1556,6 +1800,52 @@ export class History {
                         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]) => {
+                        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: constraint.secondDirInstanceCount.value,
+                                secondDirDistance: constraint.secondDirDistance.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(drawingId, rProductId, featureName);
@@ -1575,7 +1865,7 @@ export class History {
                     }, id);
                 },
                 removeInstances: async (...instances) => {
-                    var e_11, _a;
+                    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;) {
@@ -1603,12 +1893,12 @@ export class History {
                             instancesToRemove.push(instanceParam);
                         }
                     }
-                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    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_11) throw e_11.error; }
+                        finally { if (e_14) throw e_14.error; }
                     }
                     return assemblyBuilderAPI.removeInstances(drawingId, instancesToRemove);
                 },
@@ -1667,7 +1957,7 @@ export class History {
                     }, sketchId, planeId, axisId, originId);
                 },
                 transformInstances: async (...instances) => {
-                    var e_12, _a;
+                    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;) {
@@ -1699,12 +1989,12 @@ export class History {
                             instancesToTransform.push(instanceParam);
                         }
                     }
-                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                    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_12) throw e_12.error; }
+                        finally { if (e_15) throw e_15.error; }
                     }
                     return assemblyBuilderAPI.transformInstances(drawingId, instancesToTransform);
                 },
@@ -1773,7 +2063,7 @@ export class History {
                     }, partId);
                 },
                 setExpressions: async (...expressions) => {
-                    var e_13, _a;
+                    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;) {
@@ -1815,12 +2105,12 @@ export class History {
                             });
                         }
                     }
-                    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                    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_13) throw e_13.error; }
+                        finally { if (e_16) throw e_16.error; }
                     }
                     const success = await featureAPI.updateExpressions(drawingId, expressionsToSet);
                     return success;
@@ -1941,6 +2231,48 @@ export class History {
                     }
                     return null;
                 },
+                twist: async (param) => {
+                    return this.resolve(async ([rPartId, rSketchOrRegionIds]) => {
+                        const twist = await featureAPI.createFeature(drawingId, 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(drawingId, twist, resSketchOrRegionIds, param.type, limit1Param, limit2Param, directionParam, twistAngleParam, twistCenterParam, param.capEnds);
+                                return twist;
+                            }
+                        }
+                    }, param.partId, param.sketchOrRegionIds);
+                },
             };
             callback(publicApi);
             resolve(drawingId);

package/build/esm/solid.js

@@ -8,9 +8,10 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 /* eslint-disable max-lines */
 import { ccAPI } from '@buerli.io/classcad';
 import { api, getDrawing } from '@buerli.io/core';
-import { Group, Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
+import { Group, Mesh, MeshStandardMaterial, Scene } from 'three';
 import { mergeBufferGeometries } from 'three-stdlib';
 import { getDifferentColoredMeshesFromEntity } from './utils/meshes';
+const isShape = (entity) => entity && entity.type === 'Shape';
 const solidAPI = ccAPI.solid;
 const toCCVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
 const toCCNbrVec = (args) => ({ x: args[0], y: args[1], z: args[2] });
@@ -332,7 +333,7 @@ export class Solid {
                 },
                 extrude: (height, region) => {
                     return this.resolve(async () => {
-                        if (region instanceof Shape) {
+                        if (isShape(region)) {
                             const curveArray = makeCCData(region.curves);
                             return solidAPI.createExtrudeRegion(drawingId, makeNbrVec(height), curveArray);
                         }
@@ -398,7 +399,7 @@ export class Solid {
                 },
                 revolve: (position, direction, angle, region) => {
                     return this.resolve(async () => {
-                        if (region instanceof Shape) {
+                        if (isShape(region)) {
                             const curveArray = makeCCData(region.curves);
                             return solidAPI.createRevolveRegion(drawingId, makeNbrVec(position), makeNbrVec(direction), angle, curveArray);
                         }

package/build/types/history.d.ts

@@ -649,6 +649,96 @@ export declare type ApiHistory = {
         zOffsetLimits: LimitsParam;
         zRotationLimits: LimitsParam;
     }[]) => Promise<void>;
+    /**
+     * Creates a group constraint between selected instances within an assembly.
+     * @param id id of the root assembly or an assembly template to create constraints on
+     * @param instanceIds ids of instances to be grouped
+     * @param name name of the constraint
+     * @example // tbd
+     * @return id of the group constraint
+     */
+    createGroupConstraint: (id: VID, instanceIds: VID[], name: string) => Promise<ObjectID | null>;
+    /**
+     * Updates multiple group constraints.
+     * @param constraints array of constraint parameter objects. See following descriptions.
+     * @param constrId id of the constraint to update
+     * @param instanceIds ids of instances to be grouped
+     * @example // tbd
+     */
+    updateGroupConstraints: (...constraints: {
+        constrId: VID;
+        instanceIds: VID[];
+    }[]) => Promise<void>;
+    /**
+     * Makes copies of a selected instance and creates a linear pattern constraint between them.
+     * @param id id of the root assembly or an assembly template to create constraints on
+     * @param instanceId id of the instance to be copied
+     * @param mate1 contains the mate path ids to its part and its work coordinate system id, and also the flip (0-5) and reoriented (0-3) states; should belong to the selected instance
+     * @param firstDirInstanceCount number of copies over the first direction (set by z-axis of mate1)
+     * @param firstDirDistance distance between copies over the first direction (set by z-axis of mate1)
+     * @param name name of the constraint
+     * @param mate2 [optional] contains the mate path ids to its 2nd part and its work coordinate system id, and also the flip (0-5) and reoriented (0-3) states; should belong to the selected instance
+     * @param secondDirInstanceCount [optional] number of copies over the second direction (set by z-axis of mate2)
+     * @param secondDirDistance [optional] distance between copies over the second direction (set by z-axis of mate2)
+     * @example // tbd
+     * @return id of the linear pattern constraint
+     */
+    createLinearPatternConstraint: (id: VID, instanceId: VID, mate1: MateParam, firstDirInstanceCount: number | string, firstDirDistance: number | string, name: string, mate2?: MateParam, secondDirInstanceCount?: number | string, secondDirDistance?: number | string) => Promise<ObjectID | null>;
+    /**
+     * Updates multiple linear pattern constraints.
+     * @param constraints array of constraint parameter objects. See following descriptions.
+     * @param constrId id of the constraint to update
+     * @param instanceId id of the instance to be copied
+     * @param mate1 contains the mate path ids to its part and its work coordinate system id, and also the flip (0-5) and reoriented (0-3) states; should belong to the selected instance
+     * @param firstDirInstanceCount number of copies over the first direction (set by z-axis of mate1)
+     * @param firstDirDistance distance between copies over the first direction (set by z-axis of mate1)
+     * @param mate2 [optional] contains the mate path ids to its 2nd part and its work coordinate system id, and also the flip (0-5) and reoriented (0-3) states; should belong to the selected instance
+     * @param secondDirInstanceCount [optional] number of copies over the second direction (set by z-axis of mate2)
+     * @param secondDirDistance [optional] distance between copies over the second direction (set by z-axis of mate2)
+     * @example // tbd
+     */
+    updateLinearPatternConstraints: (...constraints: {
+        constrId: VID;
+        instanceId: VID;
+        mate1: MateParam;
+        firstDirInstanceCount: number | string;
+        firstDirDistance: number | string;
+        mate2?: MateParam;
+        secondDirInstanceCount?: number | string;
+        secondDirDistance?: number | string;
+    }[]) => Promise<void>;
+    /**
+     * Makes copies of a selected instance and creates a circular pattern constraint between them.
+     * @param id id of the root assembly or an assembly template to create constraints on
+     * @param instanceId id of the instance to be copied
+     * @param mate1 contains the mate path ids to its part and its work coordinate system id, and also the flip (0-5) and reoriented (0-3) states; should belong to the selected instance
+     * @param instanceCount total number of copies (clockwise around the axis set by z-axis of mate1)
+     * @param angle angle between copies (clockwise around the axis set by z-axis of mate1)
+     * @param offset offset between copies (set by z-axis of mate2)
+     * @param name name of the constraint
+     * @example // tbd
+     * @return id of the circular pattern constraint
+     */
+    createCircularPatternConstraint: (id: VID, instanceId: VID, mate1: MateParam, instanceCount: number | string, angle: number | string, offset: number | string, name: string) => Promise<ObjectID | null>;
+    /**
+     * Updates multiple circular pattern constraints.
+     * @param constraints array of constraint parameter objects. See following descriptions.
+     * @param constrId id of the constraint to update
+     * @param instanceId id of the instance to be copied
+     * @param mate1 contains the mate path ids to its part and its work coordinate system id, and also the flip (0-5) and reoriented (0-3) states; should belong to the selected instance
+     * @param instanceCount total number of copies (clockwise around the axis set by z-axis of mate1)
+     * @param angle angle between copies (clockwise around the axis set by z-axis of mate1)
+     * @param offset offset between copies (set by z-axis of mate2)
+     * @example // tbd
+     */
+    updateCircularPatternConstraints: (...constraints: {
+        constrId: VID;
+        instanceId: VID;
+        mate1: MateParam;
+        instanceCount: number | string;
+        angle: number | string;
+        offset: number | string;
+    }[]) => Promise<void>;
     /**
      * Updates limited value specified (with 'paramName') of multiple constraints
      * @param constrValues array of constraint value objects. See following parameter description for that.
@@ -1130,11 +1220,20 @@ export declare type ApiHistory = {
      * Returns the sketch region with the given sketchRegionName from the given instance or part id.
      * If sketchRegionName is not set, all sketch regions of the reference will be returned.
      * @param id id of the instance or part to look for the sketch region
-     * @param wcsName name of the sketch region to look for
+     * @param sketchRegionName name of the sketch region to look for
      * @example // tbd
      * @return array containing ids of the sketch regions
      */
     getSketchRegion: (id: VID, sketchRegionName?: string) => IDs;
+    /**
+     * Returns the sketch with the given sketchName from the given instance or part id.
+     * If sketchName is not set, all sketches of the reference will be returned.
+     * @param id id of the instance or part to look for the sketch
+     * @param sketchName name of the sketch to look for
+     * @example // tbd
+     * @return array containing ids of the sketches
+     */
+    getSketch: (id: VID, sketchName?: string) => IDs;
     /**
      * Returns the work geometry of given type with given name from the given instance or part id.
      * If the name of the work geometry is empty, all found work geometry of given type is returned
@@ -1217,6 +1316,30 @@ export declare type ApiHistory = {
      * @return found cylindrical constraint as object.
      */
     getCylindricalConstraint: (id: VID, constrName: string) => Promise<CylindricalConstraintType>;
+    /**
+     * Returns the group constraint of given instance or assembly with specified name.
+     * @param id id of the instance or assembly to look for the constraint
+     * @param constrName name of the constraint to look for
+     * @example // tbd
+     * @return found group constraint as object.
+     */
+    getGroupConstraint: (id: VID, constrName: string) => Promise<GroupConstraintType>;
+    /**
+     * Returns the linear pattern constraint of given instance or assembly with specified name.
+     * @param id id of the instance or assembly to look for the constraint
+     * @param constrName name of the constraint to look for
+     * @example // tbd
+     * @return found linear pattern constraint as object.
+     */
+    getLinearPatternConstraint: (id: VID, constrName: string) => Promise<LinearPatternConstraintType>;
+    /**
+     * Returns the circular pattern constraint of given instance or assembly with specified name.
+     * @param id id of the instance or assembly to look for the constraint
+     * @param constrName name of the constraint to look for
+     * @example // tbd
+     * @return found circular pattern constraint as object.
+     */
+    getCircularPatternConstraint: (id: VID, constrName: string) => Promise<CircularPatternConstraintType>;
     /**
      * Returns the id of the feature / operation with name = featureName. The feature can then
      * be used for further operations, like boolean, transformations and so on.
@@ -1436,6 +1559,32 @@ export declare type ApiHistory = {
      * @return id of the slice by sheet operation
      */
     sliceBySheet: (partId: VID, operationToSlice: VID, operationOfSheet: VID, sideFlag: boolean) => ID;
+    /**
+     * Creates a twist operation
+     * @param partId Id of the part to create the twist in.
+     * @param sketchOrRegionIds Id of the sketch to extrude or multiple ids of sketch regions
+     * @param type Type of twist (up, down, symmetric, custom)
+     * @param limit1 Start of twist (0 = start at sketch, only for type custom necessary)
+     * @param limit2 End of twist, which is actually the height
+     * @param direction Direction of twist (only for type custom necessary)
+     * @param twistAngle Twist angle of the sketch along height of twist
+     * @param twistCenter Point which together with direction defines the twist axis (only for type custom necessary).
+     * The actual center/start of the twist is where the defined twist axis intersects the sketch plane. For other types than
+     * custom, the center will be the bary center of the selected region.
+     * @param capEnds If true, ends will be capped, else a sheet will be created
+     * @return id of the twist operation
+     */
+    twist: (param: {
+        partId: VID;
+        sketchOrRegionIds: VID | VIDs;
+        type: ExtrusionType;
+        limit1: number | string;
+        limit2: number | string;
+        direction?: Vec<number | string>;
+        twistAngle: number | string;
+        twistCenter?: Vec<number | string>;
+        capEnds: 0 | 1;
+    }) => ID;
 };
 export declare class History {
     drawingId: DrawingID | null;
@@ -1590,6 +1739,44 @@ export declare type CylindricalConstraintType = {
     /** min and max limit for the rotation around z-Axis */
     zRotationLimits: LimitsParam;
 };
+export declare type GroupConstraintType = {
+    /** id of the constraint */
+    constrId: VID;
+    /** ids of instances to be grouped */
+    instanceIds: VID[];
+};
+export declare type LinearPatternConstraintType = {
+    /** id of the constraint */
+    constrId: VID;
+    /** id of the instance to be copied */
+    instanceId: VID;
+    /** first mate constraint (z-axis sets the first direction) */
+    mate1: MateParam;
+    /** number of copies over the first direction (set by z-axis of mate1) */
+    firstDirInstanceCount: number | string;
+    /** distance between copies over the first direction (set by z-axis of mate1) */
+    firstDirDistance: number | string;
+    /** second mate constraint (z-axis sets the second direction) */
+    mate2: MateParam;
+    /** number of copies over the second direction (set by z-axis of mate2) */
+    secondDirInstanceCount: number | string;
+    /** number of copies over the second direction (set by z-axis of mate2) */
+    secondDirDistance: number | string;
+};
+export declare type CircularPatternConstraintType = {
+    /** id of the constraint */
+    constrId: VID;
+    /** id of the instance to be copied */
+    instanceId: VID;
+    /** first mate constraint (z-axis sets the rotation axis) */
+    mate1: MateParam;
+    /** total number of copies (clockwise around the axis set by z-axis of mate1) */
+    instanceCount: number | string;
+    /** angle between copies (clockwise around the axis set by z-axis of mate1) */
+    angle: number | string;
+    /** offset between copies (set by z-axis of mate2) */
+    offset: number | string;
+};
 /**
  * Information about constraint.
  * [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
@@ -32,7 +32,7 @@
     "three-stdlib": ">=2.11.0"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.12.0",
+    "@buerli.io/classcad": "0.13.0",
     "flat-promise": "^1.0.3"
   }
 }