@buerli.io/headless 0.8.0 → 0.9.0-beta.1

package/build/types/history.d.ts

@@ -1,7 +1,6 @@
 import { BooleanOperationType, ChamferType, FlipType, ReorientedType, WorkAxisType, WorkCoordSystemType, WorkPlaneType, WorkPointType, ViewType, OrientationType, ExtrusionType, WorkGeomType, SVGModusType, LimitsParam, LimitedValue } from '@buerli.io/classcad';
-import { DrawingID, ObjectIdent, ObjectID, PointMemValue, GraphicType, InteractionInfo } from '@buerli.io/core';
+import { DrawingID, ObjectIdent, ObjectID, PointMemValue, GraphicType, InteractionInfo, AnyGeometryElement } from '@buerli.io/core';
 import { BufferGeometry, Material, Object3D, Scene } from 'three';
-export declare type Vec = number[] | PointMemValue | THREE.Vector3 | THREE.Euler;
 /**
  * History based modeling is similar to solid modeling, but it is non-destructive and
  * parametric. You can move back and forth in the modeling history and create feature
@@ -26,16 +25,19 @@ export declare type Vec = number[] | PointMemValue | THREE.Vector3 | THREE.Euler
  */
 export declare type ApiHistory = {
     /**
-     * Adds multiple products as nodes to an existing assembly at once
-     * @param nodes array of node parameter objects. See following descriptions.
-     * @param productId id or identifier of the product template to add
-     * @param ownerId id or identifier of the owner where the product template will be added to
-     * @param transformation transformation of the product template in x-, y- and z-axis
-     * @param name optional name for adding node
-     * @param options optional object containing ident property, to define a identifier for the added node
+     * Adds products as instances to root assembly, assembly instance or assembly template.
+     * - If the owner is an instance in the expanded tree, its template in the assembly container will also be updated.
+     * - If the onwer is an assembly template, all instances of the template will also be updated
+     * @param instances array of objects containing the information of "to add" instances. See following parameter descriptions.
+     * @param productId id or identifier of the product to instantiate
+     * @param ownerId id or identifier of the owner of to adding instance, owner can be root assembly, assembly instance or assembly template.
+     * @param transformation transformation (origin, x-Dir, y-Dir) of the instance
+     * @param name optional name for the instance
+     * @param options optional object containing ident property, to define a identifier for the adding instance
+     * @return array containing the ids of added instances direct to owner
      * @example // tbd
      */
-    addNodes: (...nodes: {
+    addInstances: (...instances: {
         productId: VID | ObjectIdent;
         ownerId: VID | ObjectIdent;
         transformation: Transform;
@@ -82,7 +84,7 @@ export declare type ApiHistory = {
      *
      * // Add the dimensions
      * const dimensionIds = await api.addDimensions(dimension1, dimension2)
-     * @return array of ids of the added dimensions
+     * @return array containing the ids of added dimensions
      */
     addDimensions: (...dimensions: {
         productId: VID;
@@ -115,6 +117,7 @@ export declare type ApiHistory = {
      *
      * // Create the wanted views
      * await api.create2DViews(productId, [ViewType.TOP, ViewType.RIGHT_90, ViewType.ISO], { color: 2, layer: '6'})
+     * @return array containing the ids of created views
      */
     create2DViews: (productId: VID, viewTypes: ViewType[], viewOptions?: ViewOptionsType) => IDs;
     /**
@@ -127,6 +130,7 @@ export declare type ApiHistory = {
      *
      * // Returns for each view a min and max point
      * console.info(bbs) // [[{x: -105, y: -89, z: 0}, {x: 105, y: 55, z: 0}], [...], [...]]
+     * @return array of tuples, each tuple contains a min and max value for one of the given view types. The min an max values represent a Vector with x-, y- and z-coordinates.
      */
     getBoundaryBoxFromViews: (productId: VID, viewTypes?: ViewType[]) => Promise<[Vec, Vec][]>;
     /**
@@ -176,23 +180,25 @@ export declare type ApiHistory = {
     }, dxfTemplateFilename?: string) => Promise<Uint8Array | null>;
     /**
      * Remove existing dimensions from the view.
-     * @param dimensionsIds ids of the dimensions to be removed
+     * @param dimensionIds ids of the dimensions to be removed
      * @example
      * // You can remove existing dimensions
      * await api.removeDimensions(dimensionIds)
      */
     removeDimensions: (dimensionIds: VID[]) => Promise<void>;
     /**
-     * Creates a linear pattern
+     * Creates a linear pattern operation
      * @param partId Id of the part to create the linear pattern in.
-     * @param entities included entities of linear operation.
+     * @param operations ids of the operations which are used for this linear pattern operation,
+     * e.g. box, extrusion, chamfer operation
      * @param references1 references for the first axis of the pattern. E.g. edge / work axis or 2 vertices / work points
      * @param params1 parameter object which includes inverted flag, distance, count and merged flag
      * for the first direction of the pattern.
      * @param references2 optional references for the second axis of the pattern.
      * @param params2 optional parameter object for second direction of pattern.
+     * @return id of the linear pattern operation
      */
-    linearPattern: (partId: VID, entities: VID[], references1: VID[], params1: {
+    linearPattern: (partId: VID, operations: VID[], references1: VID[], params1: {
         inverted: 0 | 1;
         distance: number | string;
         count: number | string;
@@ -203,20 +209,22 @@ export declare type ApiHistory = {
         count: number | string;
     }) => ID;
     /**
-     * Creates a circular pattern
+     * Creates a circular pattern operation
      * @param partId Id of the part to create the circular pattern in.
-     * @param entities included entities of circular operation.
+     * @param operations ids of the operations which are used for this circular pattern operation,
+     * e.g. box, extrusion, chamfer operation
      * @param references references for the rotation axis of the pattern. E.g. edge / work axis or 2 vertices / work points
      * @param params parameter object which includes inverted flag, angle, count and merged flag.
+     * @return id of the circular pattern operation
      */
-    circularPattern: (partId: VID, entities: VID[], references: VID[], params: {
+    circularPattern: (partId: VID, operations: VID[], references: VID[], params: {
         inverted: 0 | 1;
         angle: number | string;
         count: number | string;
         merged: 0 | 1;
     }) => ID;
     /**
-     * Creates an extrusion
+     * Creates an extrusion operation
      * @param partId Id of the part to create the extrusion in.
      * @param sketchOrRegionIds Id of the sketch to extrude or multiple ids of sketch regions
      * @param type Type of extrusion (up, down, symmetric, custom)
@@ -225,23 +233,27 @@ export declare type ApiHistory = {
      * @param taperAngle Angle of taper for extrusion
      * @param direction Direction of extrusion
      * @param capEnds If true, ends will be capped, else a sheet will be created
+     * @return id of the extrusion operation
      */
     extrusion: (partId: VID, sketchOrRegionIds: VID | VIDs, type: ExtrusionType, limit1: number | string, limit2: number | string, taperAngle: number | string, direction: Vec, capEnds: 0 | 1) => ID;
     /**
-     * Creates a revolve
+     * Creates a revolve operation
      * @param partId Id of the part to create the revolve in.
      * @param sketchOrRegionIds Id of the sketch to extrude or multiple ids of sketch regions
      * @param axisIds Array of ids, either [lineId] or [point1Id, point2Id], ids can be both ccId or graphicId
      * @param angle1 Start of revolve in degrees
      * @param angle2 End of revolve in degrees
      * @param inverted flag, whether to invert the axis or not
+     * @return id of the revolve operation
      */
     revolve: (partId: VID, sketchOrRegionIds: VID | VIDs, axisIds: VID[], angle1: number | string, angle2: number | string, inverted: 0 | 1) => ID;
     /**
      * Creates a boolean operation.
      * @param partId id of the part where the operation will be created on
      * @param type type of boolean operation.
-     * @param entities included entities of boolean operation, first entity is base entity
+     * @param operations ids of the operations for this boolean operation, e.g. Box, Chamfer.
+     * At least two operations are needed. First operation in the array is the basic operation,
+     * all following are the tool operations, which will be unified, subtract or intersect with/from the first operation.
      * @example
      * // Creates a box and subtracts a cylinder from it
      * const part = api.createPart('Part')
@@ -250,10 +262,11 @@ export declare type ApiHistory = {
      * api.boolean(part, BooleanOperationType.Subtraction, [box, cyl])
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the boolean operation
      */
-    boolean: (partId: VID, type: BooleanOperationType, entities: VID[]) => ID;
+    boolean: (partId: VID, type: BooleanOperationType, operations: VID[]) => ID;
     /**
-     * Creates a simple box entity
+     * Creates a box operation
      * @param partId id of the part where the box will be created
      * @param references reference of work coordinate system to place the box at
      * @param length length of the box (x-axis)
@@ -265,10 +278,11 @@ export declare type ApiHistory = {
      * const box = api.box(part, [], 20, 20, 20)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the box operation
      */
     box: (partId: VID, references: VID[], width: number | string, length: number | string, height: number | string) => ID;
     /**
-     * Creates a simple cylinder entity
+     * Creates a cylinder operation
      * @param partId id of the part where the cylinder will be created
      * @param references reference of work coordinate system to place the cylinder at
      * @param diameter diameter of the cylinder (x/y-axis)
@@ -279,10 +293,11 @@ export declare type ApiHistory = {
      * api.cylinder(part, [], 20, 50)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the cylinder operation
      */
     cylinder: (partId: VID, references: VID[], diameter: number | string, height: number | string) => ID;
     /**
-     * Creates a chamfer at the given edge references.
+     * Creates a chamfer operation
      * @param partId id of the part where the chamfers will be created
      * @param type type of chamfer operation.
      * @param references edge references where the chmamfers will be created on
@@ -297,10 +312,11 @@ export declare type ApiHistory = {
      * api.chamfer(part, ChamferType.Equal_Distance, bottomEdges, 2, 0, 0)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the chamfer operation
      */
     chamfer: (partId: VID, type: ChamferType, references: VIDs, dist1: number | string, dist2: number | string, angle: number | string) => ID;
     /**
-     * Creates a simple cone entity.
+     * Creates a cone operation.
      * @param partId id of the part where the cone will be created
      * @param references reference of work coordinate system to place the cone at
      * @param bDiameter bottom diameter of the cone
@@ -312,11 +328,12 @@ export declare type ApiHistory = {
      * api.cone(part, [], 20, 0, 20)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the cone operation
      */
     cone: (partId: VID, references: VID[], bDiameter: number | string, tDiameter: number | string, height: number | string) => ID;
     /**
      * Creates a fastened constraint between mate1 and mate2 within an assembly.
-     * @param asmId id of the assembly to create constraints on
+     * @param id id of the root assembly or an assembly template to create constraints on
      * @param mate1 contains the mate path ids to its 1st part and its work coordinate system id, and also the flip (0-5) and reoriented (0-3) states
      * @param mate2 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
      * @param xOffset defines a offset in x-axis from mate1 to mate2
@@ -347,19 +364,20 @@ export declare type ApiHistory = {
      * const wcs2 = await api.createWorkCoordSystem(partTempl2, WorkCoordSystemType.WCS_Custom, [], offset2, rot, false, 'wcs2')
      * api.cone(partTempl2, [wcs2], 30, 0.1, 30)
      *
-     * // Adds the created part templates as nodes to the root assembly
-     * const prt1 = await api.addNode(partTempl1, rootAsm, [orig, xDir, yDir])
-     * const prt2 = await api.addNode(partTempl2, rootAsm, [orig, xDir, yDir])
+     * // Adds the created part templates as instances to the root assembly
+     * const prt1 = await api.addInstances(partTempl1, rootAsm, [orig, xDir, yDir])
+     * const prt2 = await api.addInstances(partTempl2, rootAsm, [orig, xDir, yDir])
      *
-     * // Creates a fastened constraint between the nodes
+     * // Creates a fastened constraint between the instances
      * await api.createFastenedConstraint(rootAsm, { matePath: [prt1], wcsId: wcs3 }, { matePath: [prt2], wcsId: wcs2 }, 0, 0, 0, 0, 0, 'FC')
      * const geoms = await api.createBufferGeometry(rootAsm)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the fastened constraint
      */
-    createFastenedConstraint: (asmId: VID, mate1: MateParam, mate2: MateParam, xOffset: number | string, yOffset: number | string, zOffset: number | string, name: string) => Promise<ObjectID | null>;
+    createFastenedConstraint: (id: VID, mate1: MateParam, mate2: MateParam, xOffset: number | string, yOffset: number | string, zOffset: number | string, name: string) => Promise<ObjectID | null>;
     /**
      * Updates multiple fastened constraints
-     * @param constraints array of constraint parameter objects. See following descriptions.
+     * @param constraints array of constraint parameter objects. See following parameter descriptions.
      * @param mate1 contains the mate path ids to its 1st part and its work coordinate system id, and also the flip (0-5) and reoriented (0-3) states
      * @param mate2 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
      * @param xOffset defines a offset in x-axis from mate1 to mate2
@@ -377,7 +395,7 @@ export declare type ApiHistory = {
     }[]) => Promise<void>;
     /**
      * Creates a fastened origin constraint for mate1 to the origin (0, 0, 0).
-     * @param asmId id of the assembly to create constraints on
+     * @param id id of the root assembly or an assembly template to create constraints on
      * @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
      * @param xOffset defines a offset in x-axis from mate1 to mate2
      * @param yOffset defines a offset in y-axis from mate1 to mate2
@@ -401,16 +419,17 @@ export declare type ApiHistory = {
      * const wcs2 = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset2, rot, false, 'wcs')
      * api.box(partTempl, [wcs1], 30, 30, 30)
      *
-     * // Adds the created part template as a node to the root assembly
-     * const prt = await api.addNode(partTempl, rootAsm, [orig, xDir, yDir])
+     * // Adds the created part template as an instance to the root assembly
+     * const prt = await api.addInstances(partTempl, rootAsm, [orig, xDir, yDir])
      *
      * // Creates a fastened origin constraint. The box of the part will be centered in origin
      * await api.createFastenedOriginConstraint(rootAsm, { matePath: [prt], wcsId: wcs2 }, 0, 0, 0, 0, 0, 'FOC')
      *
      * const geoms = await api.createBufferGeometry(rootAsm)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial({ transparent: true, opacity: 0.5 })))
+     * @return id of the fastened origin constraint
      */
-    createFastenedOriginConstraint: (asmId: VID, mate1: MateParam, xOffset: number | string, yOffset: number | string, zOffset: number | string, name: string) => Promise<ObjectID | null>;
+    createFastenedOriginConstraint: (id: VID, mate1: MateParam, xOffset: number | string, yOffset: number | string, zOffset: number | string, name: string) => Promise<ObjectID | null>;
     /**
      * Updates multiple fastened origin constraints
      * @param constraints array of constraint parameter objects. See following descriptions.
@@ -429,15 +448,16 @@ export declare type ApiHistory = {
     }[]) => Promise<void>;
     /**
      * Creates a cylindrical constraint between mate1 and mate2 within an assembly.
-     * @param asmId id of the assembly to create constraints on
+     * @param id id of the root assembly or an assembly template to create constraints on
      * @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
      * @param mate2 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
      * @param zOffsetLimits min and max value of offset along z
      * @param zRotationLimits min and max value of rotation around z
      * @param name name of the constraint
      * @example // tbd
+     * @return id of the cylindrical constraint
      */
-    createCylindricalConstraint: (asmId: VID, mate1: MateParam, mate2: MateParam, zOffsetLimits: LimitsParam, zRotationLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
+    createCylindricalConstraint: (id: VID, mate1: MateParam, mate2: MateParam, zOffsetLimits: LimitsParam, zRotationLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
     /**
      * Updates multiple cylindrical constraints.
      * @param constraints array of constraint parameter objects. See following descriptions.
@@ -457,15 +477,16 @@ export declare type ApiHistory = {
     }[]) => Promise<void>;
     /**
      * Creates a revolute constraint between mate1 and mate2 within an assembly.
-     * @param asmId id of the assembly to create constraints on
+     * @param id id of the root assembly or an assembly template to create constraints on
      * @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
      * @param mate2 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
      * @param zOffset defines a offset in z-axis from mate1 to mate2
      * @param zRotationLimits min and max value of rotation around z
      * @param name name of the constraint
      * @example // tbd
+     * @return id of the revolute constraint
      */
-    createRevoluteConstraint: (asmId: VID, mate1: MateParam, mate2: MateParam, zOffset: number | string, zRotationLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
+    createRevoluteConstraint: (id: VID, mate1: MateParam, mate2: MateParam, zOffset: number | string, zRotationLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
     /**
      * Updates multiple revolute constraints.
      * @param constraints array of constraint parameter objects. See following descriptions.
@@ -485,7 +506,7 @@ export declare type ApiHistory = {
     }[]) => Promise<void>;
     /**
      * Creates a slider constraint between mate1 and mate2 within an assembly.
-     * @param asmId id of the assembly to create constraints on
+     * @param id id of the root assembly or an assembly template to create constraints on
      * @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
      * @param mate2 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
      * @param xOffset defines a offset in x-axis from mate1 to mate2
@@ -493,8 +514,9 @@ export declare type ApiHistory = {
      * @param zOffsetLimits min and max value of offset along z
      * @param name name of the constraint
      * @example // tbd
+     * @return id of the slider constraint
      */
-    createSliderConstraint: (asmId: VID, mate1: MateParam, mate2: MateParam, xOffset: number | string, yOffset: number | string, zOffsetLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
+    createSliderConstraint: (id: VID, mate1: MateParam, mate2: MateParam, xOffset: number | string, yOffset: number | string, zOffsetLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
     /**
      * Updates multiple slider constraints.
      * @param constraints array of constraint parameter objects. See following descriptions.
@@ -516,7 +538,7 @@ export declare type ApiHistory = {
     }[]) => Promise<void>;
     /**
      * Creates a planar constraint between mate1 and mate2 within an assembly.
-     * @param asmId id of the assembly to create constraints on
+     * @param id id of the root assembly or an assembly template to create constraints on
      * @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
      * @param mate2 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
      * @param zOffset defines a offset in z-axis from mate1 to mate2
@@ -525,8 +547,9 @@ export declare type ApiHistory = {
      * @param zRotationLimits min and max value of rotation around z
      * @param name name of the constraint
      * @example // tbd
+     * @return id of the planar constraint
      */
-    createPlanarConstraint: (asmId: VID, mate1: MateParam, mate2: MateParam, zOffset: number | string, xOffsetLimits: LimitsParam, yOffsetLimits: LimitsParam, zRotationLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
+    createPlanarConstraint: (id: VID, mate1: MateParam, mate2: MateParam, zOffset: number | string, xOffsetLimits: LimitsParam, yOffsetLimits: LimitsParam, zRotationLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
     /**
      * Updates multiple planar constraints.
      * @param constraints array of constraint parameter objects. See following descriptions.
@@ -550,7 +573,7 @@ export declare type ApiHistory = {
     }[]) => Promise<void>;
     /**
      * Creates a parallel constraint between mate1 and mate2 within an assembly.
-     * @param asmId id of the assembly to create constraints on
+     * @param id id of the root assembly or an assembly template to create constraints on
      * @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
      * @param mate2 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
      * @param xOffsetLimits min and max value of offset along x
@@ -559,8 +582,9 @@ export declare type ApiHistory = {
      * @param zRotationLimits min and max value of rotation around z
      * @param name name of the constraint
      * @example // tbd
+     * @return id of the parallel constraint
      */
-    createParallelConstraint: (asmId: VID, mate1: MateParam, mate2: MateParam, xOffsetLimits: LimitsParam, yOffsetLimits: LimitsParam, zOffsetLimits: LimitsParam, zRotationLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
+    createParallelConstraint: (id: VID, mate1: MateParam, mate2: MateParam, xOffsetLimits: LimitsParam, yOffsetLimits: LimitsParam, zOffsetLimits: LimitsParam, zRotationLimits: LimitsParam, name: string) => Promise<ObjectID | null>;
     /**
      * Updates multiple parallel constraints.
      * @param constraints array of constraint parameter objects. See following descriptions.
@@ -584,6 +608,10 @@ export declare type ApiHistory = {
     }[]) => Promise<void>;
     /**
      * Updates limited value specified (with 'paramName') of multiple constraints
+     * @param constrValues array of constraint value objects. See following parameter description for that.
+     * @param constrId id of the constraint to update the limited value
+     * @param paramName name of the limited parameter
+     * @param value new value to set
      */
     update3dConstraintValues: (...constrValues: {
         constrId: VID;
@@ -591,7 +619,7 @@ export declare type ApiHistory = {
         value: number;
     }[]) => Promise<void>;
     /**
-     * Creates the buffer geometry of the product (part or assembly).
+     * Creates the buffer geometry of any product (part or assembly).
      * @param productId id of the product to create buffer geometry from
      * @example
      * // Creates a cone with bottom diameter = 20, top diameter = 0 and height = 30
@@ -599,15 +627,16 @@ export declare type ApiHistory = {
      * api.cone(part, [], 20, 0, 30)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return array of buffer geometry
      */
     createBufferGeometry: (productId: VID) => Promise<BufferGeometry[] | undefined>;
     /**
-     * Creates ThreeJS scene from current product
+     * Creates the threeJS scene of any product (part or assembly).
      * @param productId id of the product to create scene from
      * @param options optional object to define different settings.
      * @param meshPerGeometry boolean flag to define if a part/solid will have a mesh for each
      * geometry element or if the elements will be merged to one mesh
-     * @return object containing all the created THREE objects like scene, nodes, solids and meshes
+     * @return object containing all the created THREE objects like scene, nodes and materials
      * @example // tbd
      */
     createScene: (productId?: VID, options?: {
@@ -624,7 +653,7 @@ export declare type ApiHistory = {
     }>;
     /**
      * Creates one or more expressions.
-     * @param partId id or identifier of part where to create the expression
+     * @param partId id or identifier of the part to create the expressions in
      * @param members array of members which contain a name and a value. Value can be an expression, e.g. '2 * laenge'
      * @example
      * // Creates an expression and links it with the width of the box
@@ -633,13 +662,16 @@ export declare type ApiHistory = {
      * api.box(part, [], 'ExpressionSet.width', 20, 20)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return true or false, depending on whether creating the expressions was successful or not
      */
     createExpressions: (partId: VID | ObjectIdent, ...members: {
         name: string;
         value: number | string;
     }[]) => Promise<boolean>;
     /**
-     * Creates a new assembly template. This template can be used multiple times as a sub assembly in the root assembly.
+     * Creates a new assembly template. This template will be added to the assembly container
+     * and can be instantiated multiple times as a sub assembly in the root assembly or in other assembly template.
+     * Assembly templates can only be created if the root is already an assembly.
      * @param name [optional] name of the assembly template. Default = 'Assembly'
      * @example
      * // Defines some consts
@@ -667,21 +699,22 @@ export declare type ApiHistory = {
      * const wcs2 = await api.createWorkCoordSystem(partTempl2, WorkCoordSystemType.WCS_Custom, [], offset2, rot, false, 'wcs2')
      * api.cone(partTempl2, [wcs2], 30, 0.1, 30)
      *
-     * // Adds the created part templates as nodes to the assembly
+     * // Adds the created part templates as instances to the assembly
      * // and the assembly itself multiple times to the root assembly
-     * const prt1 = await api.addNode(partTempl1, asmTempl, [orig, xDir, yDir])
-     * const prt2 = await api.addNode(partTempl2, asmTempl, [orig, xDir, yDir])
-     * const asm1 = await api.addNode(asmTempl, rootAsm, [orig, xDir, yDir])
-     * const asm2 = await api.addNode(asmTempl, rootAsm, [offset3, xDir, yDir])
+     * const prt1 = await api.addInstances(partTempl1, asmTempl, [orig, xDir, yDir])
+     * const prt2 = await api.addInstances(partTempl2, asmTempl, [orig, xDir, yDir])
+     * const asm1 = await api.addInstances(asmTempl, rootAsm, [orig, xDir, yDir])
+     * const asm2 = await api.addInstances(asmTempl, rootAsm, [offset3, xDir, yDir])
      *
      * const geoms = await api.createBufferGeometry(rootAsm)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the assembly template
      */
     createAssemblyAsTemplate: (name?: string) => ID;
     /**
-     * Creates a new rootAssembly. This is the top level assembly.
+     * Creates a new root assembly. This is the top level assembly.
      * @param name [optional] name of the root assembly. Default = 'AssemblyRoot'
-     * @param options optional object containing ident property, to define a identifier for the created root assembly
+     * @param options optional object containing ident property to define an identifier for the created root assembly
      * @example
      * // Defines some consts
      * const orig = { x: 0, y: 0, z: 0 }
@@ -698,16 +731,17 @@ export declare type ApiHistory = {
      * const wcs = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset, rot, false, 'wcs')
      * api.box(partTempl, [wcs], 30, 30, 10)
      *
-     * // Adds the created part template as a node to the root assembly
-     * const partRef = await api.addNode(partTempl, rootAsm, [orig, xDir, yDir])
+     * // Adds the created part template as an instance to the root assembly
+     * const partRef = await api.addInstances(partTempl, rootAsm, [orig, xDir, yDir])
      * const geoms = await api.createBufferGeometry(rootAsm)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the root assembly
      */
     createRootAssembly: (name?: string, options?: {
         ident?: ObjectIdent;
     }) => ID;
     /**
-     * Creates a new part.
+     * Creates a new root part. This is the top level part.
      * @param name [optional] name of the part. Default = 'Part'
      * @example
      * // Creates a box and subtracts a cylinder from it
@@ -715,10 +749,13 @@ export declare type ApiHistory = {
      * api.cylinder(part, [], 10, 100)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the root part
      */
     createPart: (name?: string) => ID;
     /**
-     * Creates a new part template. This template can be used multiple times to build assemblies.
+     * Creates a new part template. This template will be added to the part container
+     * and can be instantiated multiple times in the root assembly or in assembly templates.
+     * Part templates can only be created if the root is already an assembly.
      * @param name [optional] name of the part. Default = 'Part'
      * @example
      * // Defines some consts
@@ -736,10 +773,11 @@ export declare type ApiHistory = {
      * const wcs = await api.createWorkCoordSystem(partTempl, WorkCoordSystemType.WCS_Custom, [], offset, rot, false, 'wcs')
      * api.box(partTempl, [wcs], 30, 30, 10)
      *
-     * // Adds the created part template as a node to the root assembly
-     * const partRef = await api.addNode(partTempl, rootAsm, [orig, xDir, yDir])
+     * // Adds the created part template as an instance to the root assembly
+     * const partRef = await api.addInstances(partTempl, rootAsm, [orig, xDir, yDir])
      * const geoms = await api.createBufferGeometry(rootAsm)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the part template
      */
     createPartAsTemplate: (name?: string) => ID;
     /**
@@ -752,6 +790,7 @@ export declare type ApiHistory = {
      * @param local if true, work axis is set in local coordinates of part???
      * @param name name of the work axis, if not set default name = 'WorkAxis'
      * @example //tbd
+     * @return id of the work axis
      */
     createWorkAxis: (partId: VID, type: WorkAxisType, references: VID[], position: Vec, direction: Vec, local: boolean, name?: string) => ID;
     /**
@@ -761,7 +800,7 @@ export declare type ApiHistory = {
      * @param references references for the work coordinate system (point and 2 axis). If empty array, the work coordinate system will set to origin (0, 0, 0)
      * @param offset offset from work coordinate system in x-, y- and z-direction
      * @param rotation rotation around x-, y- and z-axis from work coordinate system
-     * @param inverted inverts the constraint between mate1 and mate2
+     * @param inverted inverts the direction of the primary axis
      * @param name name of the work coordinate system, if not set default name = 'WorkCoordSystem'
      * @example
      * // Defines some consts
@@ -787,14 +826,15 @@ export declare type ApiHistory = {
      * const wcs2 = await api.createWorkCoordSystem(partTempl2, WorkCoordSystemType.WCS_Custom, [], offset2, rot, false, 'wcs2')
      * api.cone(partTempl2, [wcs2], 30, 0.1, 30)
      *
-     * // Adds the created part templates as nodes to the root assembly
-     * const prt1 = await api.addNode(partTempl1, rootAsm, [orig, xDir, yDir])
-     * const prt2 = await api.addNode(partTempl2, rootAsm, [orig, xDir, yDir])
+     * // Adds the created part templates as instances to the root assembly
+     * const prt1 = await api.addInstances(partTempl1, rootAsm, [orig, xDir, yDir])
+     * const prt2 = await api.addInstances(partTempl2, rootAsm, [orig, xDir, yDir])
      *
-     * // Creates a fastened constraint between the nodes
+     * // Creates a fastened constraint between the instances
      * await api.createFastenedConstraint(rootAsm, { matePath: [prt1], wcsId: wcs3 }, { matePath: [prt2], wcsId: wcs2 }, 0, 0, 0, 0, 0, 'FC')
      * const geoms = await api.createBufferGeometry(rootAsm)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the work coordinate system
      */
     createWorkCoordSystem: (partId: VID, type: WorkCoordSystemType, references: VID[], offset: Vec, rotation: Vec, inverted: boolean, name?: string) => ID;
     /**
@@ -809,6 +849,7 @@ export declare type ApiHistory = {
      * @param local if true, work plane is set in local coordinates of part???
      * @param name name of the work plane, if not set default name = 'WorkAxis'
      * @example // tbd
+     * @return id of the work plane
      */
     createWorkPlane: (partId: VID, type: WorkPlaneType, references: VID[], offset: number, angle: number, position: Vec, normal: Vec, local: boolean, name?: string) => ID;
     /**
@@ -821,10 +862,11 @@ export declare type ApiHistory = {
      * @param local if true, work point is set in local coordinates of part???
      * @param name name of the work point, if not set default name = 'WorkPoint'
      * @example // tbd
+     * @return id of the work point
      */
     createWorkPoint: (partId: VID, type: WorkPointType, references: VID[], position: Vec, local: boolean, name?: string) => ID;
     /**
-     * Deletes an existing expression.
+     * Deletes existing expressions.
      * @param partId id or identifier of part to delete expressions from
      * @param members name of members to delete
      * @example
@@ -835,6 +877,7 @@ export declare type ApiHistory = {
      * await api.box(part, [], 'ExpressionSet.width', 20, 20)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return true or false, depending on whether deleting the expressions was successful or not
      */
     deleteExpressions: (partId: VID | ObjectIdent, members: string[]) => Promise<boolean>;
     /**
@@ -845,6 +888,7 @@ export declare type ApiHistory = {
      * @param strm stream of ofb file which contains the sketch
      * @param planeId id of the face or workplane to set the new sketch on
      * @param name optional name of the sketch to load from filestream
+     * @return id of the new sketch, containing the sketch elements from loaded sketch
      */
     loadSketch: (partId: VID, strm: ArrayBuffer, planeId: VID, name?: string) => ID;
     /**
@@ -854,6 +898,7 @@ export declare type ApiHistory = {
      * @param partId id of the part we want to create the new sketch and copy the sketch elements into it
      * @param sketchId id of the sketch to copy
      * @param planeId id of the face or workplane to set the new sketch on
+     * @return id of the new sketch, containing the sketch elements form copied sketch
      */
     copySketch: (partId: VID, sketchId: VID, planeId: VID) => ID;
     /**
@@ -870,8 +915,8 @@ export declare type ApiHistory = {
      */
     placeSketch: (sketchId: VID, planeId: VID, invertPlane: boolean, axisId: VID, isXAxis: boolean, invertAxis: boolean, originId: VID) => Promise<void>;
     /**
-     * Creates a simple sphere entity.
-     * @param partId id of the part where the cone will be created
+     * Creates a sphere operation
+     * @param partId id of the part where the sphere will be created
      * @param references reference of work coordinate system to place the cone at
      * @param radius bottom diameter of the cone
      * @example
@@ -880,10 +925,11 @@ export declare type ApiHistory = {
      * api.sphere(part, [], 20)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the sphere operation
      */
     sphere: (partId: VID, references: VID[], radius: number | string) => ID;
     /**
-     * Creates a fillet at the given edge references.
+     * Creates a fillet operation
      * @param partId id of the part where the fillet will be created
      * @param references edge references where the fillet will be created on
      * @param radius radius of the fillet
@@ -895,20 +941,27 @@ export declare type ApiHistory = {
      * api.fillet(part, topEdges, 2)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return id of the fillet operation
      */
     fillet: (partId: VID, references: VIDs, radius: number | string) => ID;
     /**
      * Important note: To use this method, you need to add the BuerliGeometry component to your application.
      * Otherwise the selection of geometry won't work.
-     * @see https://buerli.io/docs/training-for-programmers/More/graphics#3-using-the-buerligeometry-react-component
+     * [See this link to buerli geometry](https://buerli.io/docs/training-for-programmers/More/graphics#3-using-the-buerligeometry-react-component)
      *
      * Lets the user select geometry in graphical interface. As soon as the geometry of given type has been selected, the method
      * will return necessary information about it.
-     * @see https://buerli.io/docs/training-for-programmers/history/HowTos/useSelectionInHeadless
+     * [See this link to selections](https://buerli.io/docs/training-for-programmers/history/HowTos/useSelectionInHeadless)
+     *
+     * The _userData_ of the returned object contains additional information about the selected geometry. All geometric
+     * information in the _userData_ is already transformed to the correct position. This is especially important for
+     * assemblies.
+     *
      * @param types array of types to filter user selection.
      * @param count optional number of selections to make (count must be >= 1). Default = 1.
+     * @return array of objects containing information about selected geometries
      */
-    selectGeometry: (types: GrT[], count?: number) => Promise<InteractionInfo[]>;
+    selectGeometry: <T = AnyGeometryElement>(types: GrT[], count?: number) => Promise<InteractionInfo<T>[]>;
     /**
      * Find geometries of given type on solids in the given part at the given global positions.
      * @param partId Id of the part where geometries tried to be found.
@@ -917,41 +970,46 @@ export declare type ApiHistory = {
      * @example
      * // Find planes at two different positions
      * const planes = await api.findGeometry(productId, GraphicType.PLANE, [[{x: 50, y: 50, z: 100}], [{x: 100, y: 50, z: 50}]])
+     * @return array containing ids of found geometries
      */
     findGeometry: (partId: VID, type: GrT, positions: Vec[][]) => IDs;
     /**
-     * Returns the assembly with given name from assembly container.
+     * Returns the assembly template with given name from assembly container.
      * If asmName is empty, all assemblies from assembly container will be returned.
      * @param asmName Name of assembly to look for
      * @example // tbd
+     * @return array containing ids of assembly templates
      */
-    getAssemblyFromContainer: (asmName?: string) => IDs;
+    getAssemblyTemplate: (asmName?: string) => IDs;
     /**
-     * Returns the direct node with given name of given reference with specified name.
-     * If nodeName is empty, all nodes of given reference will be returned.
-     * @param refId Reference of the assembly to look for the node
-     * @param nodeName Name of the node to look for
+     * Returns an instance or all instances of a node, depending on whether a name is given or not.
+     * The node is the parent of the instance/instances we're looking for and can be a root assembly,
+     * another instance or an assembly template.
+     * @param id id of the node from which we are searching the children for instances that have the name we are looking for.
+     * @param instanceName name of the instance we are looking for
      * @example // tbd
+     * @return array containing the ids of the found instances
      */
-    getAssemblyNode: (refId: VID, nodeName?: string) => IDs;
+    getInstance: (id: VID, instanceName?: string) => IDs;
     /**
-     * Returns the products (array of product ids) of the given nodes (refIds).
-     * @param refIds ids of the nodes (product references) to get the product (part or assembly) from
+     * Returns the product ids of the given instance ids.
+     * @param instanceIds ids of the instances to get the product ids from
      * @example // tbd
+     * @return array containing the product ids of the given instance ids
      */
-    getProductOfNode: (refIds: VID[]) => IDs;
+    getProductsOfInstances: (instanceIds: VID[]) => IDs;
     /**
      * Returns the id of the current product
      * @example // tbd
      */
     getCurrentProduct: () => ID;
     /**
-     * Sets the node with refId to the new current node
+     * Sets the instance with id to the new current instance
      *
-     * @param refId Reference id of the node to set as the current
+     * @param id id of the instance to set as the current
      * @example // tbd
      */
-    setCurrentNode: (refId: VID) => Promise<void>;
+    setCurrentInstance: (id: VID) => Promise<void>;
     /**
      * Sets the product with productId to the new current product
      *
@@ -960,30 +1018,38 @@ export declare type ApiHistory = {
      */
     setCurrentProduct: (productId: VID) => Promise<void>;
     /**
-     * Returns the id of the current node
+     * Returns the id of the current instance
      * @example // tbd
+     * @return id of the current instance
      */
-    getCurrentNode: () => ID;
+    getCurrentInstance: () => ID;
     /**
-     * Returns the coordinate system of the node with the
-     * given refId. Where the node is an instance in the expanded tree of any product template
+     * Returns the global transformation of the given id.
+     * Currently only ids of instances supported.
      *
-     * @param refId Reference id of the node to get the coordinate system from
+     * @param id id of the object to get the global transformation from
      * @example // tbd
+     * @return transformation of instance as two-dimensional array containing origin position and direction for x, y and z
+     * [
+     *  [origin.x, origin.y, origin.z],
+     *  [xVec.x, xVec.y, xVec.z],
+     *  [yVec.x, yVec.y, yVec.z],
+     *  [zVec.x, zVec.y, zVec.z]
+     * ]
      */
-    getCoordSysFromNode: (refId: VID) => Promise<number[][]>;
+    getTransformation: (id: VID) => Promise<number[][]>;
     /**
-     * Returns the part with given name from part container.
+     * Returns the part template with given name from part container.
      * If partName is empty, all parts from part container will be returned.
      * @param partName Name of part to look for
      * @example // tbd
+     * @return array containing ids of part templates
      */
-    getPartFromContainer: (partName?: string) => IDs;
+    getPartTemplate: (partName?: string) => IDs;
     /**
-     * @deprecated use getWorkGeometry() instead, getWorkCoordSystem() will be removed in a future release.
-     *
      * Returns the work coord system with the given wcsName from the given reference.
      * If wcsName is not set, all work coord systems of the reference will be returned.
+     * @deprecated use getWorkGeometry() instead, getWorkCoordSystem() will be removed in a future release.
      * @param refId id of the reference to look for the work coord system
      * @param wcsName name of the work coord system to look for
      * @example
@@ -994,37 +1060,39 @@ export declare type ApiHistory = {
      * const yDir = { x: 0, y: 1, z: 0 }
      * const nutBoltAsm = await api.createRootAssembly('NutBolt_Asm')
      * const bolt = await api.loadProduct(arraybuffer, 'ofb')
-     * const boltRefId = await api.addNode(bolt, nutBoltAsm, [pt0, xDir, yDir])
+     * const boltRefId = await api.addInstances(bolt, nutBoltAsm, [pt0, xDir, yDir])
      * const wcsIdOrigin = await api.getWorkCoordSystem(boltRefId, 'WCS_Origin')
      * await api.createFastenedOriginConstraint(nutBoltAsm, { refId: boltRefId, wcsId: wcsIdOrigin[0] }, 0, 0, 0, 0, 0, 'FOC')
      * const geoms = await api.createBufferGeometry(nutBoltAsm)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return array containing ids of work coordinate systems
      */
-    getWorkCoordSystem: (refId: VID, wcsName?: string) => IDs;
+    getWorkCoordSystem: (id: VID, wcsName?: string) => IDs;
     /**
-     * Returns the sketch region with the given sketchRegionName from the given reference.
+     * 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 refId id of the reference to look for the sketch region
+     * @param id id of the instance or part to look for the sketch region
      * @param wcsName name of the sketch region to look for
      * @example // tbd
+     * @return array containing ids of the sketch regions
      */
-    getSketchRegion: (refId: VID, sketchRegionName?: string) => IDs;
+    getSketchRegion: (id: VID, sketchRegionName?: string) => IDs;
     /**
-     * Returns the work geometry of given type with given name. If the name of the work geometry is empty,
-     * all found work geometry of given type is returned
-     * @param refId id of the reference to look for the work geometry
+     * 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
+     * @param id id of the instance or part to look for the work geometry
      * @param type type of the work geometry to look for
      * @param wgName optional name of the work geometry to look for
+     * @return array containing ids of the work geometry
      */
-    getWorkGeometry: (refId: VID, type: WorkGeomType, wgName?: string) => IDs;
+    getWorkGeometry: (id: VID, type: WorkGeomType, wgName?: string) => IDs;
     /**
-     * @deprecated use specific methods e.g. getFastenedConstraint() instead, getConstraint() will be removed in a future release.
-     *
      * Returns information about a constraint in the given reference
+     * @deprecated use specific methods e.g. getFastenedConstraint() instead, getConstraint() will be removed in a future release.
      * @param refId id of the reference to look for the constraint
      * @param constrName name of the constraint to look for
      * @example // tbd
-     * @returns
+     * @return array containing information about the constraint
      * [
      *    constraintId,
      *    [ reference id of first mate, workcoordsystem id of first mate, flip type of first mate, reoriented type of first mate ],
@@ -1036,79 +1104,81 @@ export declare type ApiHistory = {
      */
     getConstraint: (refId: VID, constrName?: string) => Promise<ConstraintType>;
     /**
-     * Returns the fastened constraint of given reference with specified name.
-     * @param refId id of the reference to look for the constraint
+     * Returns the fastened constraint of given instance or assembly id 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
-     * @returns found fastened constraint as object.
+     * @return found fastened constraint as object.
      */
-    getFastenedConstraint: (refId: VID, constrName: string) => Promise<FastenedConstraintType>;
+    getFastenedConstraint: (id: VID, constrName: string) => Promise<FastenedConstraintType>;
     /**
-     * Returns the fastened origin constraint of given reference with specified name.
-     * @param refId id of the reference to look for the constraint
+     * Returns the fastened origin 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
-     * @returns found fastened origin constraint as object.
+     * @return found fastened origin constraint as object.
      */
-    getFastenedOriginConstraint: (refId: VID, constrName: string) => Promise<FastenedOriginConstraintType>;
+    getFastenedOriginConstraint: (id: VID, constrName: string) => Promise<FastenedOriginConstraintType>;
     /**
-     * Returns the revolute constraint of given reference with specified name.
-     * @param refId id of the reference to look for the constraint
+     * Returns the revolute 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
-     * @returns found revolute constraint as object.
+     * @return found revolute constraint as object.
      */
-    getRevoluteConstraint: (refId: VID, constrName: string) => Promise<RevoluteConstraintType>;
+    getRevoluteConstraint: (id: VID, constrName: string) => Promise<RevoluteConstraintType>;
     /**
-     * Returns the slider constraint of given reference with specified name.
-     * @param refId id of the reference to look for the constraint
+     * Returns the slider 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
-     * @returns found slider constraint as object.
+     * @return found slider constraint as object.
      */
-    getSliderConstraint: (refId: VID, constrName: string) => Promise<SliderConstraintType>;
+    getSliderConstraint: (id: VID, constrName: string) => Promise<SliderConstraintType>;
     /**
-     * Returns the planar constraint of given reference with specified name.
-     * @param refId id of the reference to look for the constraint
+     * Returns the planar 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
-     * @returns found planar constraint as object.
+     * @return found planar constraint as object.
      */
-    getPlanarConstraint: (refId: VID, constrName: string) => Promise<PlanarConstraintType>;
+    getPlanarConstraint: (id: VID, constrName: string) => Promise<PlanarConstraintType>;
     /**
-     * Returns the parallel constraint of given reference with specified name.
-     * @param refId id of the reference to look for the constraint
+     * Returns the parallel 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
-     * @returns found parallel constraint as object.
+     * @return found parallel constraint as object.
      */
-    getParallelConstraint: (refId: VID, constrName: string) => Promise<ParallelConstraintType>;
+    getParallelConstraint: (id: VID, constrName: string) => Promise<ParallelConstraintType>;
     /**
-     * Returns the cylindrical constraint of given reference with specified name.
-     * @param refId id of the reference to look for the constraint
+     * Returns the cylindrical 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
-     * @returns found cylindrical constraint as object.
+     * @return found cylindrical constraint as object.
      */
-    getCylindricalConstraint: (refId: VID, constrName: string) => Promise<CylindricalConstraintType>;
+    getCylindricalConstraint: (id: VID, constrName: string) => Promise<CylindricalConstraintType>;
     /**
-     * Returns the id of the feature with name = featureName. The feature can then
+     * 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.
-     * @param partId id of the part where to look for the feature
+     * @param partId id of the part where to look for the feature / operation
      * @param featureName name of the feature to look for
      * @example // tbd
+     * @return id of the feature / operation
      */
     getFeatureByName: (partId: VID, featureName: string) => ID;
     /**
      * Returns an object containing the center of gravity and the volume of the given
-     * product, node or solid. Depending on the input parameter the calculations were made
+     * product, instance or solid. Depending on the input parameter the calculations were made
      * on a single solid, a part, a subassembly, the whole model, ... E.g. the center of gravity of
      * a root assembly, will be the sum of all solid's center of gravity over the whole assembly structure
      *
-     * @param objectId id of the part, assembly, node or solid we want the information from
+     * @param id id of the part, assembly, instance or solid we want the information from
      * @example // tbd
+     * @return object containing the geometry information
      */
-    getGeometryInformation: (objectId: VID) => Promise<ModelInfo | null>;
+    getGeometryInformation: (id: VID) => Promise<ModelInfo | null>;
     /**
      * Writes the current drawing to a stream and returns the data.
      *
@@ -1118,109 +1188,121 @@ export declare type ApiHistory = {
      *
      * @param type type to write
      * @example // tbd
+     * @return stream data
      */
     save: (type: 'ofb' | 'stp') => Promise<Uint8Array | null>;
     /**
-     * POSTs the result to the given url.
+     * Writes the current drawing to a stream and POSTs the result to the given url.
      * @param url The url to POST the model to.
      * @param filetype The file type be saved (ofb, stp).
      * @example // tbd
+     * @return true if saving was successful
      */
     saveToUrl: (url: string, filetype: 'ofb' | 'stp') => Promise<boolean>;
     /**
      * Loads the given buffer.
      * @param content data as arraybuffer
      * @param type type of the data to load
+     * @param options optional object containing ident property to define an identifier for the loaded root product
      * @example // tbd
+     * @return array containing the id of the loaded product in the file
      */
-    load: (content: ArrayBuffer, type: 'ofb' | 'stp') => Promise<number[] | null>;
+    load: (content: ArrayBuffer, type: 'ofb' | 'stp', options?: {
+        ident?: ObjectIdent;
+    }) => Promise<number[] | null>;
     /**
      * Loads from the given url.
      * @param url The url to load data from.
      * @param filetype The type of data delivered by the url (ofb, stp).
+     * @param options optional object containing ident property to define an identifier for the loaded root product
      * @example // tbd
+     * @return array containing the id of the loaded product from url
      */
-    loadFromUrl: (url: string, filetype: 'ofb' | 'stp') => Promise<number[] | null>;
+    loadFromUrl: (url: string, filetype: 'ofb' | 'stp', options?: {
+        ident?: ObjectIdent;
+    }) => Promise<number[] | null>;
     /**
-     * Loads a product into the current drawing.
+     * Loads a product into the current drawing and adds it to the part- or assembly container.
      * @param content data as arraybuffer
      * @param type type of the data to load
-     * @param options optional object containing ident property, to define a identifier for the loaded product
+     * @param options optional object containing ident property to define an identifier for the loaded product
      * @example
      * // Loads an existing product
      * const part = api.loadProduct(arraybuffer, 'ofb')
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return array containing the id of the loaded products
      */
     loadProduct: (content: ArrayBuffer, type: 'ofb' | 'stp', options?: {
         ident?: ObjectIdent;
     }) => Promise<number[] | null>;
     /**
-     * Loads a product from the given URL into the current drawing.
+     * Loads a product from the given URL into the current drawing and adds it to the part- or assembly container.
      * @param url The url to load data from.
      * @param filetype The type of data delivered by the url ('ofb', 'stp').
      * @param options optional object containing ident property, to define a identifier for the loaded product
      * @example // tbd
+     * @return array containing the id of the loaded products
      */
     loadProductFromUrl: (url: string, filetype: 'ofb' | 'stp', options?: {
         ident?: ObjectIdent;
     }) => Promise<number[] | null>;
     /**
-     * Creates a new feature and appends geometry to it. This method can be used to import specific geometry
+     * Creates a import feature operation and appends geometry to it. This method can be used to import specific geometry
      * which can be used for further operations like boolean, translations and so on.
      * @param partId id of the part where to add the new feature
      * @param content data buffer to add to the import feature
      * @param format the content format
      * @param name optional name for the feature, default = 'Import'
      * @example // tbd
+     * @return id of the import feature operation
      */
     importFeature: (partId: VID, content: ArrayBuffer, format: 'stp' | 'step', name?: string) => ID;
     /**
-     * Removes multiple nodes from an assembly node at once
-     * @param nodes array of node parameter objects. See following descriptions.
-     * @param referenceId id or identifier of the node to remove
+     * Removes instances from root assembly, other instances or assembly templates.
+     * @param instances array of instance objects. See following parameter descriptions.
+     * @param id id or identifier of the instance to remove
      * @example // tbd
      */
-    removeNodes: (...nodes: {
-        referenceId: VID | ObjectIdent;
+    removeInstances: (...instances: {
+        id: VID | ObjectIdent;
     }[]) => Promise<void>;
     /**
-     * Transforms the nodes with referenceId with the given transformation within an assembly.
-     * The transformations are local to the nodes parent (owner), which is an assembly.
-     *
-     * @param nodes array of node parameter objects. See following descriptions.
-     * @param referenceId id or identifier of the node to transform
-     * @param transformation transformation (origin, xDir, yDir) of the node (local to the owner).
+     * Transforms instances by the given transformation.
+     * The transformations are local to the instances parent, which is an assembly.
+     * @param instances array of instance objects. See following descriptions.
+     * @param id id or identifier of the instance to transform
+     * @param transformation transformation (origin, xDir, yDir) of the instance local to the owner.
      * @example // tbd
      */
-    transformNodes: (...nodes: {
-        referenceId: VID | ObjectIdent;
+    transformInstances: (...instances: {
+        id: VID | ObjectIdent;
         transformation: Transform;
     }[]) => Promise<void>;
     /**
-     * Translates a feature along a given axis.
+     * Creates a translate operation
      * @param partId id ot the part where features will be translated
-     * @param featureIds ids of the features which will be translated
+     * @param operations ids of the operations which are used for this translate operation,
+     * e.g. box, extrusion, chamfer operation
      * @param references references which define the direction of translation. E.g workaxis, 2 workpoints,..
      * @param inverted flag if direction is inverted or not
      * @param distance distance of translation
      * @example // tbd
+     * @return id of the translate operation
      */
-    translate: (partId: VID, featureIds: VID[], references: VID[], inverted: 0 | 1, distance: number | string) => ID;
+    translate: (partId: VID, operations: VID[], references: VID[], inverted: 0 | 1, distance: number | string) => ID;
     /**
-     * @deprecated use translate() instead, updateTranslate() will be removed in a future release.
-     *
      * Updates a already created translation. To update value will be distance of translation
+     * @deprecated use translate() instead, updateTranslate() will be removed in a future release.
      * @param translationId id of the translation (feature id) which will be updated
      * @param distance new value for distance
      * @example // tbd
      */
     updateTranslate: (translationId: VID, distance: number) => Promise<void>;
     /**
-     * @deprecated use findGeometry() instead, pick() will be removed in a future release.
-     *
      * Returns found vertices, edges or faces depending on
-     * given type an points. Given points define where to look for elements.
+     * given type and points. Given points define where to look for elements.
+     * @deprecated use findGeometry() instead, pick() will be removed in a future release.
      * @param partId id of the part to pick elements
      * @param type type of element to pick
      * @param points points containing 3D coordinates to look for possible element
@@ -1232,11 +1314,11 @@ export declare type ApiHistory = {
      * api.fillet(part, edges, 2)
      * const geoms = await api.createBufferGeometry(part)
      * return geoms.map(geom => new THREE.Mesh(geom, new THREE.MeshStandardMaterial()))
+     * @return array containing ids of found geometries
      */
     pick: (partId: VID, type: 'vertex' | 'edge' | 'face', points: Vec[]) => IDs;
     /**
      * Updates multiple expressions in different parts at once
-     *
      * @param expressions array of expression objects containing the part id and the expression to set
      * @param partId id or identifier of part to update expression
      * @param members array of members to update which contain a name and a value. Value can be an expression, e.g. '2 * laenge'
@@ -1251,42 +1333,48 @@ export declare type ApiHistory = {
         }[];
     }[]) => Promise<boolean>;
     /**
-     * Mirrors the entities of a feature at the position of the plane reference
+     * Creates a mirror operation.
+     * Mirrors the entities of an operation at the position of the plane reference
      * @param partId id of the part where the mirror will be created
-     * @param entities id of the feature/operation we want to use entities from
+     * @param operations ids of the operations which are used for this mirror operation,
+     * e.g. box, extrusion, chamfer operation
      * @param references id of the references which will be used to mirror (e.g. Workplane)
      */
-    mirror: (partId: VID, entities: VID[], references: VID[]) => Promise<ObjectID | null>;
+    mirror: (partId: VID, operations: VID[], references: VID[]) => Promise<ObjectID | null>;
     /**
      * Removes the given operations or the operations which are added after 'toOperation' in history, depending
      * on whether operations or toOperation parameter is given.
      * @param operations ids of all to remove operations. First element in the array will be removed first.
-     * This means operations which depend on eacht other, need to be removed from newest to oldest.
+     * This means operations which depend on each other, need to be removed from newest to oldest.
      * @param toOperation all operations, from rollback bar until the id of this operation, will be deleted
      */
     removeOperations: (operations: VID[], toOperation: VID) => Promise<void>;
     /**
-     * Creates and returns the mate path as array from the given reference id up to the current node.
-     * This helps to get the right path to set constraints between nodes which are located in
-     * subassemblies.
-     * @param refId id of the node to set the constraint on
+     * Creates and returns the mate path as array from the given instance id up to the current instance.
+     * This helps to get the right path to set constraints between instances which are located in
+     * nested assemblies.
+     * @param instanceId id of the instance to get the mate path from
+     * @return array containing the ids as a path from given instance to current instance
      */
-    getMatePath: (refId: VID) => Promise<ObjectID[]>;
+    getMatePath: (instanceId: VID) => Promise<ObjectID[]>;
     /**
+     * Creates a slice operation.
      * Slices the entities of the given operations by the given reference.
      * @param partId id of the part where the slice will be created
-     * @param operations ids of the operations from which its entities will be sliced
+     * @param operations ids of the operations which are used for this slice operation,
+     * e.g. box, extrusion, chamfer operation
      * @param reference id of the workplane reference to use for the slice
-     * @param sideFlag  flag to toggle which side of the sliced entities will be kept
+     * @param sideFlag flag to toggle which side of the slice will be kept
      * @return id of the slice operation
      */
     slice: (partId: VID, operations: VID[], reference: VID, sideFlag: boolean) => ID;
     /**
+     * Creates a slice by sheet operation.
      * Slices the entity of an operation with a sheet entity of another operation
      * @param partId id of the part where the slice will be created
-     * @param operationToSlice id of the operation of which its entity will be sliced
-     * @param operationOfSheet id of the operation of which its entity is a sheet and used to slice the entity of operationToSlice
-     * @param sideFlag  flag to toggle which side of the sliced entity will be kept
+     * @param operationToSlice id of the operation which will be sliced in this slice by sheet operation
+     * @param operationOfSheet id of the operation which is used as the slice
+     * @param sideFlag flag to toggle which side of the slice will be kept
      * @return id of the slice by sheet operation
      */
     sliceBySheet: (partId: VID, operationToSlice: VID, operationOfSheet: VID, sideFlag: boolean) => ID;
@@ -1319,89 +1407,158 @@ declare type MateParam = {
     reoriented: ReorientedType;
 };
 declare type GrT = GraphicType.POINT | GraphicType.LINE | GraphicType.ARC | GraphicType.CIRCLE | GraphicType.PLANE | GraphicType.CYLINDER | GraphicType.CONE | GraphicType.SPHERE | GraphicType.NURBSCURVE | GraphicType.NURBSSURFACE;
+/**
+ * Array type containing three points of type Point = {x: number, y: number, z: number}.
+ *  - [0] = origin position containing x-, y- and z-coordinates
+ *  - [1] = x-direction vector
+ *  - [2] = y-direction vector
+ */
 export declare type Transform = [Point, Point, Point];
 export declare type DimensionType = {
+    /** id of the product to create the 2d dimension in */
     productId: VID;
+    /** object containing specific parameters for the dimension */
     dimParam: {
+        /** type of the dimension, currently linear and radial dimensions can be created */
         dimType: 'LinearDimension';
+        /** optional name for the dimension */
         dimName?: string;
+        /** optional label for the dimension, this will appear in the 2d view next to the dimension. E.g. "Width = " */
         dimLabel: string;
+        /** optional value for the label, if empty the value will calculated automatically */
         dimValue?: number | null;
+        /** start position of the dimension */
         dimStartPos: Vec;
+        /** end position of the dimension */
         dimEndPos: Vec;
+        /** position of the dimension text (combination of label and value) */
         dimTextPos: Vec;
+        /** text orientation from x-axis counter clockwise, angle in radians */
         dimTextAngle: number;
+        /** orientation of dimension, e.g. HORIZONTAL = (along x-axis) or VERTICAL = (along y-axis) */
         dimOrientation: OrientationType;
+        /** color of the dimension (autocad color index), 256 = color will be taken from layer */
         dimColor?: number;
+        /** layer where the dimension will appear, e.g. "2", depends on layer definitions in dxf template */
         dimLayer?: string;
     };
+    /** type of the view e.g. top, front, iso, ... where the dimension will be visible in the dxf file */
     dxfView: ViewType;
 };
 export declare type ViewOptionsType = {
+    /** optional color (autocad color index) to set for the 2d view, if color = 256 then color will be taken from layer definition */
     color?: number;
+    /** optional layer to set for the 2d view, layers are defined in the dxf file */
     layer?: string;
 };
 export declare type FastenedOriginConstraintType = {
+    /** id of the constraint */
     constrId: VID;
+    /** first mate constraint */
     mate1: MateParam;
+    /** offset in x-direction */
     xOffset: number | string;
+    /** offset in y-direction */
     yOffset: number | string;
+    /** offset in z-direction */
     zOffset: number | string;
 };
 export declare type FastenedConstraintType = {
+    /** id of the constraint */
     constrId: VID;
+    /** first mate constraint */
     mate1: MateParam;
+    /** second mate constraint */
     mate2: MateParam;
+    /** offset in x-direction */
     xOffset: number | string;
+    /** offset in y-direction */
     yOffset: number | string;
+    /** offset in z-direction */
     zOffset: number | string;
 };
 export declare type RevoluteConstraintType = {
+    /** id of the constraint */
     constrId: VID;
+    /** first mate constraint */
     mate1: MateParam;
+    /** second mate constraint */
     mate2: MateParam;
+    /** offset in z-direction */
     zOffset: number | string;
+    /** min and max limit for the rotation around z-Axis */
     zRotationLimits: LimitsParam;
 };
 export declare type SliderConstraintType = {
+    /** id of the constraint */
     constrId: VID;
+    /** first mate constraint */
     mate1: MateParam;
+    /** second mate constraint */
     mate2: MateParam;
+    /** offset in x-direction */
     xOffset: number | string;
+    /** offset in y-direction */
     yOffset: number | string;
+    /** min and max limit for the z-offset */
     zOffsetLimits: LimitsParam;
 };
 export declare type PlanarConstraintType = {
+    /** id of the constraint */
     constrId: VID;
+    /** first mate constraint */
     mate1: MateParam;
+    /** second mate constraint */
     mate2: MateParam;
+    /** offset in z-direction */
     zOffset: number | string;
+    /** min and max limit for the x-offset */
     xOffsetLimits: LimitsParam;
+    /** min and max limit for the y-offset */
     yOffsetLimits: LimitsParam;
+    /** min and max limit for the rotation around z-Axis */
     zRotationLimits: LimitsParam;
 };
 export declare type ParallelConstraintType = {
+    /** id of the constraint */
     constrId: VID;
+    /** first mate constraint */
     mate1: MateParam;
+    /** second mate constraint */
     mate2: MateParam;
+    /** min and max limit for the x-offset */
     xOffsetLimits: LimitsParam;
+    /** min and max limit for the y-offset */
     yOffsetLimits: LimitsParam;
+    /** min and max limit for the z-offset */
     zOffsetLimits: LimitsParam;
+    /** min and max limit for the rotation around z-Axis */
     zRotationLimits: LimitsParam;
 };
 export declare type CylindricalConstraintType = {
+    /** id of the constraint */
     constrId: VID;
+    /** first mate constraint */
     mate1: MateParam;
+    /** second mate constraint */
     mate2: MateParam;
+    /** min and max limit for the z-offset */
     zOffsetLimits: LimitsParam;
+    /** min and max limit for the rotation around z-Axis */
     zRotationLimits: LimitsParam;
 };
 /**
  * Information about constraint.
  * [
  *    constraintId,
- *    [ path to product reference, workcoordsystem id of first mate, flip type of first mate, reoriented type of first mate ],
- *    [ path to product reference, workcoordsystem id of second mate, flip type of second mate, reoriented type of second mate ],
+ *    [ path to product reference,
+ *      workcoordsystem id of 1st mate,
+ *      flip type of 1st mate,
+ *      reoriented type of 1st mate ],
+ *    [ path to product reference,
+ *      workcoordsystem id of 2nd mate,
+ *      flip type of 2nd mate,
+ *      reoriented type of 2nd mate ],
  *    xOffset,
  *    yOffset,
  *    zOffset
@@ -1425,4 +1582,12 @@ export declare type ConstraintType = [
     number,
     number
 ];
+/**
+ * General vector type representing following types:
+ * - number[]
+ * - PointMemValue = {x: number, y: number, z: number}
+ * - THREE.Vector [See threejs documentation](https://threejs.org/docs/?q=Vect#api/en/math/Vector3)
+ * - THREE.Euler [See threejs documentation](https://threejs.org/docs/?q=Euler#api/en/math/Euler)
+ */
+export declare type Vec = number[] | PointMemValue | THREE.Vector3 | THREE.Euler;
 export {};